🤖 AI

When Retrieval Fails Before It Begins: Structurally Indirect Prerequisite Eviction as a Retention Failure in Agentic Memory

This paper identifies and addresses "structurally indirect prerequisite eviction," a pre-retrieval memory failure in agentic systems where weakly aligned upstream blocks are discarded, by introducing a deterministic benchmark and demonstrating that Dependency-aware Semantic Garbage Collection (DSGC) significantly improves full-chain retention rates.

Original authors: Minkyu Song

Published 2026-08-24

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Minkyu Song

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine a computer program designed to act like a human agent, capable of solving complex, multi-step problems over a long period. To do this, it needs a memory, a place to store the facts, rules, and decisions it encounters along the way. However, just like a human brain or a physical filing cabinet, this digital memory has a strict limit on how much it can hold at any one time. As new information arrives, old information must be discarded to make room. This process of deciding what to keep and what to throw away is called retention. Once the memory is full, the program must also decide which of the remaining pieces of information to pull out to answer a specific question; this is called retrieval. For years, researchers have focused almost entirely on the second step, trying to build better systems for finding the right information once it is already in the store. They assumed that if the answer was needed, the necessary facts would survive the initial cleanup.

A researcher at Yonsei University has challenged this assumption. They discovered that the most critical failure often happens before the search even begins. In their study, they found that when a computer agent is forced to delete old information to save space, it frequently throws away a specific type of fact: a piece of information that is not directly mentioned in the current question but is absolutely required to understand the answer. They call this a "structurally indirect prerequisite." It is a fact that sits upstream in a chain of logic, weakly connected to the words of the question, yet essential for the reasoning to work. If this hidden link is deleted, the remaining information becomes useless, no matter how good the search engine is. The researcher demonstrated that by changing the rules of what gets kept, they could save these fragile links and allow the agent to solve problems it previously failed.

The researcher built a controlled environment to test this idea, creating a scenario where an agent had to remember a chain of three connected facts to answer a single question. They designed the test so that the first fact in the chain was barely related to the question's wording, while the third fact was very similar. Under standard rules, the computer would keep the third fact because it looked relevant and delete the first one because it looked irrelevant. But without that first fact, the middle fact made no sense, and the answer was lost. The researcher found that in these tight situations, where the memory was nearly full, standard systems failed to keep the full chain of reasoning in about 97 percent of the cases when using a basic text-matching system. The agent would keep the obvious pieces but lose the invisible glue that held them together.

To fix this, the researcher introduced a new rule for deciding what to keep, which they named Dependency-aware Semantic Garbage Collection. Instead of just looking at how much a piece of text resembles the current question, this new rule looks at the connections between pieces of information. If a piece of information is highly relevant to the question, the rule checks what other facts it depends on. If a less obvious fact is required to make sense of the relevant one, the system treats that less obvious fact as important too. It essentially says, "If you need this, you must also keep the thing that explains it." This is a one-step process: it protects the immediate parent of a relevant fact, but it does not reach further back into the history of the conversation.

When they applied this new rule, the results changed dramatically. In the same difficult tests where the old systems failed almost every time, the new system successfully kept the entire chain of reasoning in 90 percent of the cases when using a basic text-matcher, and in 100 percent of the cases when using a more advanced language understanding system. The researcher verified this by looking at the exact logs of every test run. They saw that the system was indeed saving the critical, weakly connected facts that the old systems had discarded. The new rule did not just randomly keep more things; it specifically saved the missing links that allowed the logic to flow.

However, the study also revealed the limits of this approach. The new rule works by looking one step back. If a chain of facts is very long, or if the memory is filled with a huge number of distracting pieces of information, the rule can struggle. In tests where the memory size was doubled, the system's ability to keep the full chain dropped significantly when using the basic text-matcher, though it remained perfect with the advanced language system. This suggests that while protecting immediate dependencies is a powerful tool, it is not a magic bullet for every situation. The researcher also found that the rule works best when the memory is under moderate pressure—large enough to hold the answer, but small enough that the computer has to make hard choices. If the memory is too full, even the smartest rules cannot save everything; if it is too empty, the computer doesn't need to choose at all.

The significance of this work lies in shifting the focus of how we think about artificial intelligence memory. For a long time, the goal was to build better search engines for the data that remained. This study shows that the search engine is useless if the data it needs has already been thrown away. The real challenge is not just finding the right answer, but ensuring that the necessary context survives the cleanup process. By treating memory management as a structural problem rather than just a matching problem, the researcher showed that agents can maintain their ability to reason through complex tasks. They proved that keeping a reasoning chain intact requires protecting the invisible, indirect links that hold the logic together, even when those links do not look important on the surface. This insight offers a clearer path forward for building agents that can remember and reason over long periods without losing the thread of their own thoughts.

Technical Summary: Structurally Indirect Prerequisite Eviction in Agentic Memory

1. Problem Definition

The paper identifies a specific failure mode in agentic memory systems operating under a fixed token budget: Structurally Indirect Prerequisite Eviction.

Existing retrieval-centered paradigms (e.g., RAG, GraphRAG) implicitly assume that necessary evidence survives the eviction phase. However, this work isolates a pre-retrieval failure where the memory store becomes incomplete before retrieval begins. This occurs when a "structurally indirect prerequisite"—an upstream block essential for a downstream decision but weakly aligned lexically or semantically with the current query—is evicted due to budget pressure.

Once such a block is discarded, no downstream retrieval procedure can recover it, as it is no longer present in the active prompt-visible store. The author argues that retention is logically prior to retrieval: retention decides what remains, while retrieval ranks what is left.

2. Methodology

Operational Definitions

The author establishes a rigorous framework to distinguish this failure from retrieval failure, surface forgetting, or reasoning failure:

Structurally Indirect Prerequisite: A block $b_i$ in the reasoning chain is structurally indirect if it is a necessary prerequisite for a downstream block $b_j$ (where $b_j$ depends on $b_i$ ), yet $b_i$ has lower query similarity than $b_j$ .
Retention-Stage Failure: Occurs when a retention policy evicts $b_i$ while retaining the more query-similar $b_j$ , thereby breaking the reasoning chain before retrieval can occur.

Benchmark Construction

To study this in isolation, the author constructed a deterministic, reproducible benchmark:

Synthetic Scenarios: Scenarios consist of 20 blocks: a reasoning chain (3 blocks deep), "honeypot" distractors (high similarity to the query but no structural role), and filler noise.
Control vs. Target:
- Control: Chains where all blocks are query-aligned (similarity-only policies succeed).
- Target: Chains containing a structurally indirect prerequisite (similarity-only policies fail).
Ground Truth: Prerequisite edges are supplied explicitly, allowing the experiment to test retention independently of graph induction.
Encoders: Evaluations use both a strict lexical encoder (surface overlap) and a dense sentence encoder (semantic understanding).

Proposed Solution: DSGC

The paper proposes Dependency-aware Semantic Garbage Collection (DSGC), a minimal one-hop graph-aware retention rule inspired by tracing garbage collection.

Mechanism: Instead of searching for garbage to evict, DSGC propagates "liveness" from query-facing blocks (roots) to their immediate prerequisites.
Scoring: The retention score $I_i$ for a block is the sum of its raw semantic relevance ( $r_i$ ) and a propagation term ( $\pi_i$ ) derived from its dependent downstream blocks:
$I_i = r_i + \lambda_\pi \sum_{j:(j,i) \in E} r_j$
Selection: Blocks are greedily retained based on $I_i$ until the token budget is exhausted. The rule is strictly one-hop; it does not perform multi-step diffusion or re-rank during retrieval.

3. Key Results

Main Suite Performance

Under a fixed budget multiplier ( $M=2.0$ ), DSGC significantly outperforms similarity-only baselines in retaining full reasoning chains:

Lexical Encoder: Full-chain retention improved from 0.03 (similarity-only) to 0.90 (DSGC).
Sentence Encoder: Full-chain retention improved from 0.23 (similarity-only) to 1.00 (DSGC).
Controls: All methods achieved 1.00 retention on control scenarios, confirming that DSGC does not degrade performance on retrieval-friendly cases.

Granular Analysis & Boundaries

One-Hop Limit: In "Profile Target" scenarios (high difficulty), the lexical encoder showed residual failures (0.80 retention) where the oldest prerequisite (two hops away) was still evicted. Trace diagnostics confirmed that the immediate prerequisite (one hop) was successfully rescued, but the distant block was lost due to insufficient residual lexical support.
Hyperparameter Stability: Performance remained robust across propagation weights ( $\lambda_\pi \in \{0.5, 1.0, 2.0\}$ ).
Budget Dynamics: The method is most effective in intermediate budget regimes ( $M=2.0$ ). In tight budgets ( $M=1.0$ ), even DSGC struggles; in loose budgets ( $M=5.0$ ), the distinction between policies diminishes as most blocks survive.
Scaling: When context size increased from 20 to 50 blocks, DSGC with dense encoders maintained 1.00 retention, but performance degraded under the sparse lexical encoder (dropping to 0.33 for Profile Targets), indicating a limit to the one-hop rule under high noise.

4. Contributions

Operational Definition: A precise definition of "structurally indirect prerequisite eviction" that separates retention failure from downstream retrieval failure.
Reproducible Benchmark: A deterministic trigger with fixed seeds, dependency-sensitive targets, and trace diagnostics that decompose failures into displaced blocks and score margins.
DSGC Rule: A simple, one-hop graph-aware retention policy that treats agentic context eviction as a reachability problem rather than a pure semantic ranking problem.
Mechanistic Analysis: Trace-level diagnostics that validate the one-hop propagation mechanism and identify the specific boundary (multi-hop distance) where the rule degrades.

5. Significance and Claims

The paper claims to establish retention-stage failure as a distinct and critical failure boundary in agentic memory, separate from retrieval or reasoning errors.

Shift in Paradigm: The work argues that agentic memory should be viewed as a dynamic managed system where the primary question shifts from "Which block is most similar?" to "Which blocks must remain live for the reasoning chain to stay intact?"
Feasibility of Structural Retention: The results demonstrate that even a minimal, one-hop structural propagation rule can substantially close the gap between surface-similarity retention and chain-intact reasoning, particularly under budget pressure.
Systems Perspective: By isolating retention from graph induction, the paper provides a controlled base case for studying how dependency edges can be utilized to preserve reasoning chains, suggesting that future systems should integrate structural reachability into their eviction policies before relying on complex retrieval expansion.

The author concludes that while the one-hop rule has limits (specifically regarding multi-hop distance and sparse encoders), it validates the principle that preserving structural prerequisites is a necessary condition for successful long-horizon agent reasoning.