IE as Cache: Information Extraction Enhanced Agentic Reasoning

Abstract: Information Extraction aims to distill structured, decision-relevant information from unstructured text, serving as a foundation for downstream understanding and reasoning. However, it is traditionally treated merely as a terminal objective: once extracted, the resulting structure is often consumed in isolation rather than maintained and reused during multi-step inference. Moving beyond this, we propose \textit{IE-as-Cache}, a framework that repurposes IE as a cognitive cache to enhance agentic reasoning. Drawing inspiration from hierarchical computer memory, our approach combines query-driven extraction with cache-aware reasoning to dynamically maintain compact intermediate information and filter noise. Experiments on challenging benchmarks across diverse LLMs demonstrate significant improvements in reasoning accuracy, indicating that IE can be effectively repurposed as a reusable cognitive resource and offering a promising direction for future research on downstream uses of IE.

• The paper introduces a dynamic IE-as-Cache framework that enables LLMs to iteratively extract and refine query-specific evidence for robust reasoning.
• The methodology utilizes schema generation and on-demand extraction to maintain a minimal, query-relevant memory cache that mitigates contextual noise.
• Experimental results show significant improvements on logical QA, agentic planning, and summarization tasks, demonstrating the practical benefits of dynamic cache updates.

Information Extraction as Cognitive Cache for Agentic LLM Reasoning

Motivation and Problem Formulation

Traditional Information Extraction (IE) has predominantly been formulated as a pipeline endpoint—structure is distilled from text and then consumed as a static input for downstream tasks. This paradigm is fundamentally limited for the dynamic, multi-step reasoning and decision-making that characterizes agentic LLM systems operating over noise-rich and unstructured input. The central thesis of "IE as Cache: Information Extraction Enhanced Agentic Reasoning" (2604.14930) is that IE should be repositioned as a reusable, dynamically maintained cognitive cache: LLM agents iteratively extract, refine, and consume compact intermediate representations as a bridge between high-entropy text and the internal agent state.

This framing is grounded in the critical bottlenecks faced by LLMs on complex tasks: susceptibility to semantic distractors, context window overrun, information decay, and inefficient reprocessing of redundant context in long-form documents. Inspired by the hierarchical memory design of modern computing architectures, the IE-as-Cache framework leverages query-driven, structured extraction as an analog to cognitive cache memory, mediating between costly external storage (raw text) and the agent's actively manipulated reasoning state.

Figure 1: Cognitive analogy between hierarchical computer memory and text reasoning. IE functions as a bridge between raw text and the reasoning agent, mirroring the role of a hardware cache.

IE-as-Cache Framework

The IE-as-Cache architecture consists of two tightly coupled components: Query-Driven Information Extraction for initialization and dynamic Cache-Aware Agentic Reasoning for ongoing deliberation. The agent receives a user query $Q$ and raw text $T$, and maintains a compact, structured cache $C$—the working memory—which is selectively updated through targeted actions, decoupling information need identification from extraction.

Query-Driven Extraction

Conventional IE pipelines are schema-centric, leveraging fixed extraction templates. In contrast, for agentic reasoning, extraction schemas must be dynamically generated, conditioned on the semantics of the query. The proposed framework adopts a schema-decoupled, two-stage routine:

1. Schema Generation: Generate a compact, query-aligned schema $S$ that specifies the relevant slots or evidence organization for the reasoning task.
2. Schema-Guided Extraction: Populate $S$ with extractions $E$ from $T$, filtered for semantic salience.

Crucially, this approach produces intermediate structured representations (e.g., tables, slots) that instantiate the cache, providing a high-density summary tailored to the agent's objective.

Cache-Aware Agentic Reasoning

The agent now reasons over $C$ instead of the full text. At each step, the LLM can trigger actions to seek additional information—"cache misses"—by issuing refined information requests $q_t$ and performing on-demand extraction with the precomputed schema $S$. The cache is explicitly maintained: after each action, the output $T$0 is merged, deduplicated, and pruned with respect to existing cache entries, ensuring the working memory remains minimal and query-relevant.

This design diverges sharply from static context or pure tool-use paradigms, which treat context as immutable or append raw observations, amplifying context bloat and noise accumulation.

Figure 2: Unlike prior context mechanisms, IE-as-Cache introduces a dynamic read-write cache, filtering noise by keeping full text external and only active information in working memory.

Experimental Results

The evaluation covers challenging, noise-rich tasks spanning logical QA (TACT), agentic planning (Calendar Scheduling), and query-focused summarization (QMSUM), benchmarking against leading LLMs (GPT-4o, Llama3.1, Qwen-3) and strong pipeline baselines: Standard Prompting, Chain-of-Thought (CoT), ReAct agentic loop, and IE-as-Tool (static tabularization).

Logical QA (TACT)

On the TACT benchmark, which requires reasoning across distributed evidence with distracting context, IE-as-Cache achieves 71.77 Exact Match (EM) with GPT-4o compared to 61.29 for the strongest baseline (IE-as-Tool), a +10.5 EM improvement. Gains are even more pronounced for mid-sized and small models (Llama3.1-8B: 38.71 vs 27.42), substantiating the cache’s critical role in mitigating model capacity constraints under long-context reasoning.

Agentic Planning

For the Calendar Scheduling task—demanding strict constraint satisfaction over heterogeneous schedule fragments—IE-as-Cache outperforms ReAct by 8.2 EM on GPT-4o (65.20 vs 57.00), indicating the cache’s superiority for constraint management and conflict detection.

Query-Focused Summarization

In QMSUM, standard agentic loops (ReAct) even degrade performance relative to vanilla prompting, whereas IE-as-Cache consistently improves over all baselines (GPT-4o: 35.21 vs 32.03 for Generic), showing that compact cache updates yield more coherent and relevant summaries over high-entropy dialogue.

Cache Update and Extraction Analysis

Ablations confirm that dynamic cache update is essential: removing updates lowers TACT EM from 71.77 to 65.32 (GPT-4o), underscoring the need for iterative evidence refinement in multi-hop reasoning. Semantic similarity between extracted cache and gold references correlates tightly with accuracy, and even near-optimal final performance is achieved without access to ground-truth schemas, demonstrating robustness and information sufficiency of the proposed extraction routines.

Theoretical and Practical Implications

The IE-as-Cache framework reconceptualizes information extraction as an inference-time, modular, updateable middle layer bridging external knowledge and agent cognition. This shift has multiple implications:

• Robustness: Filtering and maintaining only high-utility evidence reduces distraction and error propagation—a systemic solution to the "lost in the middle" and "irrelevant context" failure modes in LLMs.
• Model Agnosticism and Efficiency: Gains manifest across model scales and families, particularly benefitting resource-constrained deployments.
• Compatibility: The cache abstraction is orthogonal to agentic reasoning architectures (ReAct, Tree of Thoughts, plugin-based tool-use) and can readily augment existing inference pipelines for enhanced controllability over memory management.
• Generalizability: While validated in text reasoning, the cognitive cache paradigm is germane to multi-modal, retrieval-augmented, and user-personalized agent systems, with direct analogs in retrieval-augmented generation, recommendation filtering, and sequential decision-making, all of which benefit from compact state persistence and controlled evidence updating.

Future Directions

Explicit cognitive cache management opens frontiers in agentic system design, including:

• Learned cache maintenance policies (e.g., RL-based persistence/pruning over intermediate tables)
• Task-specific cache structuring for complex planning, instruction-following, or dialog modeling
• Integration with retrieval-augmented and knowledge-grounded generation pipelines for scalable information intake and multi-domain reasoning
• Foundation model alignment via curriculum learning/selective activation of decision-relevant cache state

Conclusion

IE-as-Cache reframes information extraction as an active, inference-time memory mechanism for agentic LLMs, yielding state-of-the-art performance under challenging, noise-rich reasoning tasks. The framework demonstrates that a dynamic, task-conditioned cache—explicitly maintained and refined via agent interaction—enables both higher reasoning accuracy and greater efficiency, and provides a design template with broad relevance for future modular, robust, and adaptive AI systems (2604.14930).