memfly

name	memfly
title	MemFly: On-the-Fly Memory Optimization via Information Bottleneck
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2602.07885
keywords	["Memory Management","Information Bottleneck","LLM Agents","Memory Retrieval","Long-term Memory"]
description	Optimize agent long-term memory by treating it as an information bottleneck problem. Dynamically compress redundant information while preserving task-relevant content through semantic-symbolic-topological hybrid retrieval.

MemFly: Information Bottleneck Memory Optimization

Problem Context

LLM agents struggle with effective long-term memory management. As interaction history grows, memory becomes bloated with redundant information, making relevant evidence retrieval expensive and ineffective. Traditional approaches either keep everything (wasteful) or apply uniform summarization (lossy). The core challenge: compress memory while preserving task-critical information without knowing future task demands.

Core Concept

MemFly treats long-term memory as an information bottleneck optimization problem. It dynamically constructs a three-layer memory hierarchy (Notes → Keywords → Topics) while minimizing two competing objectives:

1. Compress: Remove redundant information
2. Preserve: Maintain task-relevant content

During memory construction, an LLM-based optimizer performs three operations (Merge, Link, Append) guided by redundancy and complementarity scores. During retrieval, three pathways (semantic, symbolic, topological) work synergistically to find relevant information across levels.

Architecture Overview

• Three-Layer Memory Hierarchy: Notes (raw), Keywords (entities), Topics (concepts)
• Information Bottleneck Optimization: Greedy Merge/Link/Append operations
• Redundancy Scoring: Identify and consolidate duplicate information
• Complementarity Assessment: Preserve novel, task-relevant content
• Hybrid Retrieval System: Macro-semantic, micro-symbolic, topological pathways
• Reciprocal Rank Fusion: Combine results from multiple retrieval paths
• Iterative Refinement: Progressively expand evidence for complex reasoning

Implementation

The information bottleneck memory construction:

class MemoryOptimizer:
    """
    Optimize memory through information bottleneck principles.
    Compress redundancy while preserving task-relevant information.
    """

    def __init__(self, model, max_tokens=50000):
        self.model = model
        self.max_tokens = max_tokens
        self.memory = {
            : [],        
            : (),  
            : []        
        }

     ():
        
          existing_notes:
             

        
        similarities = [
            .model.similarity(new_note, existing)
             existing  existing_notes
        ]
         (similarities)

     ():
        
        
        task_relevance = .model.task_relevance(
            new_note, task_context)

        
        memory_text = .join(.memory[])
        novelty =  - .model.similarity(new_note, memory_text)

          * task_relevance +  * novelty

     ():
        
        redundancy = .compute_redundancy_score(
            new_note, .memory[])
        complementarity = .compute_complementarity_score(
            new_note, task_context)

        
         redundancy > :
            
            ._merge_with_most_similar(new_note)
         complementarity > :
            
            .memory[].append(new_note)
            
            keywords = .model.extract_entities(new_note)
            .memory[].update(keywords)
        

     ():
        
        topics = .model.cluster_by_topic(.memory[])
        .memory[] = topics
        
        .topic_graph = {
            topic: notes  topic, notes  topics.items()
        }