Long-term experience needs storage, utility, and admission checks¶

Updated 2026-10-30 · 57 topic entries / 8 representative comparisons

MemGPT decides where information lives, MemPrice allocates fidelity within a limited window, and CMP studies how to identify utility. Voyager turns successful programs into skills, VaG manages admission risk, and SkillRise tests curation on later tasks. Fit, relevance, legitimacy, and future usefulness are four different questions. EMMA assigns structured memory to controller, agent, and skill, limiting each edit by failure scope and requiring actual use in the next attempt.

Mechanisms · Trade-offs · Cross-paper questions · Updates

How to read this card

The table compares representative methods. It is not a shared-benchmark leaderboard. Teaching examples are not measured results.

Mechanism comparison¶

Axes: Whether the object is a raw event, compressed representation, runtime state, or executable skill · Whether decisions happen at write, read, eviction, or durable admission · Whether value comes from similarity, current success, randomized exposure, or downstream tasks · Whether raw details and faulty descendants can be recovered or reverted

Paper and source	Mechanism	Benefits and trade-offs
MemGPT · Original source Sections in the Chinese source: 背景与主要改动, 核心公式, 复现边界	Manages core data, active context, and external archives in tiers; function calls and heartbeat control paging.	External capacity is not present visibility, and retrieval can omit evidence. Deterministic local keys and proxy costs are not a semantic retrieval service.
MemPrice: Online Memory Allocation via Adaptive Pricing for Long-Horizon Agents · Original source Sections in the Chinese source: 背景与主要改动, 核心公式, 本地复现与边界	Chooses one form per memory from raw, summary, abstraction, keywords, or delete. Knapsack enforces a hard budget; queue price reflects persistent occupancy.	Joint allocation depends on utility and token sizes. Details evicted from the window require archive refresh. The local path executes DP and state contracts only.
Causal Memory Policy: Making Memory Utility Identifiable by Intervening on Retrieval · Original source Sections in the Chinese source: 背景与主要改动, 核心公式, 复现边界	Reserves balanced randomized exposure in a fixed candidate pool, estimates net treatment/control effects and standard errors under that design, and protects uncertain memories.	Treatment of one item changes other slots' distributions, so effects are not independent additive coefficients. Synthetic results do not establish real QA or long-term deletion policies.
Voyager · Original source Sections in the Chinese source: 背景与主要改动, 核心公式, 复现边界	An automatic curriculum proposes tasks. After execution and feedback-driven revision, successful programs become retrievable, composable skills.	One environment success has prerequisites. Local skills are structured tool plans without Mineflayer, GPT-4, or real Minecraft.
When Self-Evolution Backfires: Pre-Commit Gating against Skill Contamination in LLM Agents · Original source Sections in the Chinese source: 背景与主要改动, 核心公式, 复现边界	Checks structure, harmless behavior, and semantic consistency before durable write-back, then selects compatible Hot sets by marginal value.	Pre-write checks precede reactive deletion but are limited by coverage. Local core operators do not turn candidate discovery into complete capability evolution.
SkillRise · Original source Sections in the Chinese source: 背景与主要改动, 核心公式, 复现边界	One policy alternates solving and document curation. Current outcomes supervise solving; discounted downstream outcomes supervise curation.	Task sequences must expose transfer value. Local tests check state and phase credit, not the paper's model RL.
Remembering Is Not Enough: Refining Memories and Learning When to Use Them in Multi-Agent Systems · Original source Sections in the Chinese source: 背景与主要改动, 核心公式	Uses paired effects, scope-first attribution, dual-reference repair gates, and resets evidence on version change.	Scope, defect, and replay scores are external. Rules do not replace LLM diagnosis or repair.
EMMA: Structured Episodic Memory for Multi-Agent Workflow Synthesis · Original source Sections in the Chinese source: 背景与主要改动, 核心公式, 高成本完整实验	Organizes persistent memory by controller, agent, and skill, editing only the responsible entry for the failure scope. Execution slips do not become durable experience; overflow first splits incomplete steps.	A single-edit guard does not establish semantics, and safety judgment is external. Exercise an accepted edit on the next attempt; an unused final edit is not improvement. The full multi-environment system was not reproduced.

Trade-off analysis¶

Allocation needs utility but does not create causal evidence¶

MemGPT moves information to archives, and MemPrice allocates representation levels within the window. Both need a keep decision. CMP studies identification instead: a memory retrieved disproportionately on difficult questions cannot be blamed for associated failures without randomized controls. When feeding CMP estimates into allocation, retain exposure design and uncertainty; net effects under fixed slots are not freely additive item values.

Sources: MemGPT · MemPrice: Online Memory Allocation via Adaptive Pricing for Long-Horizon Agents · Causal Memory Policy: Making Memory Utility Identifiable by Intervening on Retrieval

Current success, durable admission, and future usefulness happen at different times¶

Voyager accumulates successful programs as skills. VaG considers effects on descendants, checking before write-back and assessing compatibility in use. SkillRise scores curation from downstream outcomes: current success mainly evaluates solving, not whether documentation helps later. These are different evidence contracts, not a ranking. Record execution, admission, and cross-task learning separately.

Sources: Voyager · When Self-Evolution Backfires: Pre-Commit Gating against Skill Contamination in LLM Agents · SkillRise

October 29: New method and source changes¶

DiscernMem separates wrong memory scope from content defects. Pair single-memory and no-memory replays under the same task, seed, and configuration, then check repairs against both parent-memory and no-memory references. This constrains simple reflection append: poor team results cannot be blamed on one memory, and a new version cannot inherit old measured effects. Local work covers measurement and version contracts, not LLM repair or replay.

Sources: MemGPT · Remembering Is Not Enough: Refining Memories and Learning When to Use Them in Multi-Agent Systems

Identify which entry to change, then show the change helps¶

DiscernMem uses isolated injection and paired no-memory replay to distinguish scope from defects and gates repairs against parent-memory and no-memory references. EMMA organizes editing by controller, agent specialization, and skill ownership; each reflection edits only one responsible entry, while execution slips affect only the temporary plan. One measures attribution and repair; the other limits the edit layer and how it must be exercised. Structural legality is not paired benefit, and an external semantic-safety Boolean is not an implemented LLM review.

Sources: EMMA: Structured Episodic Memory for Multi-Agent Workflow Synthesis · Remembering Is Not Enough: Refining Memories and Learning When to Use Them in Multi-Agent Systems

Cross-paper questions¶

Try answering before expanding the explanation. Each question relates at least two papers.

If MemPrice selects a high-utility memory, why does CMP ask how utility was measured?¶

Show answer and example

Answer: Knapsack optimizes supplied utilities and sizes, not their reliability. Low success on tasks that often retrieve a memory can reflect selection bias. CMP uses balanced randomized exposure and controls to estimate net effect with a standard error. Slot substitution affects the result, so it cannot become an independent additive knapsack value unconditionally.

Illustrative example: A troubleshooting memory is retrieved for the hardest incidents. Determine what happens without it before interpreting low success or budgeting window space.

Sources: MemPrice: Online Memory Allocation via Adaptive Pricing for Long-Horizon Agents · Causal Memory Policy: Making Memory Utility Identifiable by Intervening on Retrieval

Why can't a Voyager program that succeeded once enter VaG's long-term library unchecked alongside all other skills?¶

Show answer and example

Answer: One execution supports that path under its environment, not harmlessness under other prerequisites or compatibility with existing skills. VaG checks structure, behavior, and semantics before writing, then chooses compatible sets by marginal value. Success, harmlessness, and combined benefits remain separate gates.

Illustrative example: A skill works in an empty directory but implicitly deletes old files. The original success does not validate a shared directory.

Sources: Voyager · When Self-Evolution Backfires: Pre-Commit Gating against Skill Contamination in LLM Agents

Why can't SkillRise use Voyager-style current success to reward curation directly?¶

Show answer and example

Answer: Current success measures actions just taken; a document's utility emerges on later related tasks. SkillRise separates solve and curate phases and applies discounted downstream returns to the latter's generated tokens. Successful program admission does not supply this cross-task credit. A polished but unhelpful summary should not be rewarded automatically.

Illustrative example: A solver can succeed by luck but record only the answer. Downstream evaluation reveals the lack of reusable steps.

Sources: SkillRise · Voyager

Why might a repaired memory that beats its parent still be rejected?¶

Show answer and example

Answer: The parent can be harmful. A candidate must also match or beat no-memory, retain historical task performance, and not increase complete failures. One positive difference does not satisfy both non-regression references.

Illustrative example: Parent memory scores 0.2, the repair 0.4, and no memory 0.8. Beating the parent does not establish usefulness.

Sources: MemGPT · Remembering Is Not Enough: Refining Memories and Learning When to Use Them in Multi-Agent Systems

Does EMMA's one-entry edit satisfy DiscernMem's causal attribution and repair checks?¶

Show answer and example

Answer: No. Single edits limit scope and clarify responsibility but still need actual exercise and rerun. DiscernMem separately uses paired isolated memory and no-memory results on matching tasks and seeds, then checks that the candidate is no worse than both parent and no-memory. Structure and effect have different acceptance conditions.

Illustrative example: Writing a transient retrieval typo into a permanent skill violates EMMA scope. Correcting the skill text does not prove that memory helps more than omitting it.

Sources: EMMA: Structured Episodic Memory for Multi-Agent Workflow Synthesis · Remembering Is Not Enough: Refining Memories and Learning When to Use Them in Multi-Agent Systems

Update log¶

Updates record new approaches, changed trade-offs, and follow-up evidence.

2026-10-30 · Reviewed EMMA's three ownership levels, single edits by scope, overflow, and required exercise on the next attempt. Distinguished these from DiscernMem's paired attribution and dual-baseline repair gate and preserved the boundary around unimplemented semantic services.

Affected: EMMA: Structured Episodic Memory for Multi-Agent Workflow Synthesis · Remembering Is Not Enough: Refining Memories and Learning When to Use Them in Multi-Agent Systems

2026-10-29 · DiscernMem separates wrong memory scope from content defects. Pair single-memory and no-memory replays under the same task, seed, and configuration, then check repairs against both parent-memory and no-memory references. This constrains simple reflection append: poor team results cannot be blamed on one memory, and a new version cannot inherit old measured effects. Local work covers measurement and version contracts, not LLM repair or replay.

Affected: Remembering Is Not Enough: Refining Memories and Learning When to Use Them in Multi-Agent Systems

2026-10-27 · Initial version: compared tiered storage, memory pricing, utility under randomized exposure, accumulation of successful programs, precommit admission, and downstream skill credit.

Covers 55 topic entries; see the full list below.

All 57 topic entries

The full catalog follows. The main comparison covers the representative papers listed above.

Paper-by-paper questions · All deep dives