メニュー
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.
デフォルトでは、最初にソースを確認する Prompt が選択されています。直接コマンドに切り替えるか、ローカルコピーをダウンロードすることもできます。
インストールを決める前に、SKILL.md と SkillsMP に表示されている付属ファイルをお読みください。
Codex または Claude でインストール この Prompt をコピーして Codex、Claude、または他のアシスタントに貼り付けると、Skill ページを確認してインストールできます。
直接コマンドでは確認用 Prompt が省略されます。実行前にソースを確認してください。
npx skills add https://github.com/ADu2021/skillXiv --skill memflyコマンドは1行のまま表示されます。コピー前に横へスクロールして全体を確認してください。
ローカルで確認しますか？SkillsMP が現在取得できるファイルをダウンロードできます。
Convert arXiv papers into ready-to-use agent skills using category-aware extraction. First classifies the paper into one or more of 11 research categories, then applies a specialized extraction pipeline for each category — because different types of papers produce different types of usable knowledge. A single paper can yield multiple skills if it spans categories. Use this skill whenever the user wants to turn a paper into a skill, extract practical techniques from research, build a skill library from papers, convert arXiv papers into reusable agent instructions, or batch-process multiple papers into skills. Also trigger when someone asks about extracting actionable knowledge from papers, making research practical for LLM agents, or systematically converting academic contributions into structured agent capabilities.
Establish regret bounds for behavior cloning with discretized actions combining statistical error and quantization error terms. Prove smoothness requirements for safe quantizer design, show that learning-based quantizers fail these requirements, and propose model-based augmentation to reduce error dependence from H² to H.
Dynamically allocate LoRA ranks per-layer during fine-tuning instead of using fixed uniform ranks. Learn optimal rank for each layer and subject via variational framework with discretized exponential distribution, reducing memory footprint while maintaining fidelity and text-alignment.
SOC 職業分類に基づく
SKILL.md を表示中
| 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. |
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.
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:
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.
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()
}
Hybrid retrieval system combining three pathways:
class HybridRetriever:
"""
Retrieve relevant memory through semantic, symbolic, topological paths.
Combines results using Reciprocal Rank Fusion.
"""
def __init__(self, memory_optimizer):
self.memory = memory_optimizer.memory
self.topic_graph = memory_optimizer.topic_graph
self.model = memory_optimizer.model
def macro_semantic_navigation(self, query, k=5):
"""
Pathway 1: Navigate through Topics for high-level localization.
Reduces search space before detailed retrieval.
"""
# Find most relevant topic
topic_scores = {
topic: self.model.similarity(query, ' '.join(notes))
for topic, notes in self.topic_graph.items()
}
best_topic = max(topic_scores, key=topic_scores.get)
# Return notes in best topic
return self.topic_graph[best_topic][:k]
def micro_symbolic_anchoring(self, query, k=5):
"""
Pathway 2: Extract entities from query and match in keywords.
Provides precise entity-based retrieval.
"""
# Extract entities from query
entities = self.model.extract_entities(query)
# Find notes containing these entities
relevant_notes = []
for note in self.memory['notes']:
note_entities = self.model.extract_entities(note)
overlap = len(entities & note_entities)
if overlap > 0:
relevant_notes.append((note, overlap))
# Sort by entity overlap and return top k
relevant_notes.sort(key=lambda x: x[1], reverse=True)
return [note for note, _ in relevant_notes[:k]]
def topological_expansion(self, seed_notes, k=5):
"""
Pathway 3: Expand from seed notes through topic associations.
Finds logically related evidence.
"""
expanded = set(seed_notes)
for note in seed_notes:
# Find notes in same topics
for topic, notes in self.topic_graph.items():
if note in notes:
expanded.update(notes)
return list(expanded)[:k]
def retrieve_with_fusion(self, query, task_context, k=5):
"""
Combine all three pathways using Reciprocal Rank Fusion.
"""
# Run all pathways in parallel
semantic_results = self.macro_semantic_navigation(query, k)
symbolic_results = self.micro_symbolic_anchoring(query, k)
# Topic expansion from symbolic results
topological_results = self.topological_expansion(
symbolic_results, k)
# Reciprocal Rank Fusion: weighted combination
rrf_scores = {}
for i, note in enumerate(semantic_results):
rrf_scores[note] = rrf_scores.get(note, 0) + 1/(i+1)
for i, note in enumerate(symbolic_results):
rrf_scores[note] = rrf_scores.get(note, 0) + 1/(i+1)
for i, note in enumerate(topological_results):
rrf_scores[note] = rrf_scores.get(note, 0) + 1/(i+1)
# Return top k by RRF score
sorted_notes = sorted(
rrf_scores.items(),
key=lambda x: x[1],
reverse=True
)
return [note for note, _ in sorted_notes[:k]]
def iterative_refinement(self, query, task_context, max_rounds=3):
"""
For complex queries, progressively expand evidence.
Stop when sufficient evidence gathered.
"""
evidence = self.retrieve_with_fusion(query, task_context, k=5)
for round_num in range(max_rounds):
# Evaluate if current evidence suffices
sufficiency = self.model.evaluate_evidence_sufficiency(
query, evidence, task_context)
if sufficiency > 0.8:
break
# Expand topologically
evidence.extend(
self.topological_expansion(evidence, k=3)
)
return evidence
When to use:
Memory construction tuning:
Retrieval configuration:
Expected improvements:
Implementation checklist:
Information bottleneck memory optimization enables efficient long-term memory for agents by compressing redundancy while preserving task-relevant information. The hybrid retrieval system leverages semantic, symbolic, and topological pathways to find evidence across scales of abstraction.