Memory and skills: retrieval, reuse, and invalidation¶
简体中文 · English
Agents / 228 questions · 57 papers
Try answering each question before opening the explanation. The bank grows as papers and questions are added.
Read this topic's comparisons, analysis, and cross-paper Q&A
228 questions · 57 papers
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why can a long-running agent keep its chat history while running out of inference cache memory?
Show answer and example
Answer: Logical conversation stores text, while KV cache stores each layer's intermediate representations of past tokens. Their purpose and footprint differ. Longer conversation increases cache memory and subsequent reads. Cache Engineering manages that state directly while preserving logical history, but recovering evicted cache still costs computation.
Illustrative example: Example: Ten thousand tool-log lines can remain in the conversation even while their KV is inactive. Reusing those logs later can require recomputing representations.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why can the same final text prefix correspond to different, nonreusable KV caches?
Show answer and example
Answer: KV depends on the history and positions visible when it was computed. Dropping tokens at different times can alter later states. repos must also transform RoPE keys for their new positions; updating indices alone or rotating values is wrong. Cache identity must therefore track position versions and operation history, not just logical text.
Illustrative example: Example: Evicting a tool response before generation versus afterward changes what later tokens could see. Matching final retained text does not make those caches interchangeable.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
How does direct KV management differ from summarizing text for recovery and reuse?
Show answer and example
Answer: Summarization changes logical input and can invalidate later KV, requiring fresh prefill. Direct management preserves logical history but changes active state and position versions. Different operation timing can produce different KV for the same final text and token set, so cache reuse identity must include history.
Illustrative example: Example: Dropping tool KV before versus after generating a sentence can change that sentence's hidden state even when the final retained text is identical.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Why does repos rotate keys but not apply the same RoPE transform to values?
Show answer and example
Answer: Moving a position from p to q adjusts an already rotated key by R(q)R(p)^-1, while the value stays unchanged. drop itself does not renumber. The cache system also needs operation history and versions. The local run does not implement AKV or serving; a few tensor rotations are not full cache engineering.
Illustrative example: Example: Moving a key from position ten to five undoes the old rotation and applies the new one. Rotating its value would change how its content is read.
Sections in the Chinese source: 核心公式, 本地复现, 成本与复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Should the most related memories always be kept, and what resource limits does TokenWorth face?
Remembering Has a Price: Learning Memory Worth under Resource Constraints
Show answer and example
Answer: Memory capacity, interactions, and generation length are finite. A long, superficially relevant memory can crowd out more useful information. TokenWorth treats retention and use as value allocation under resource competition rather than maximizing library size or similarity alone.
Illustrative example: Example: A long guide repeats known steps, while a short note records a key permission restriction. The shorter note can deserve a slot despite weaker word overlap.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why use one memory-worth model for both retrieval and eviction rather than rank only by similarity?
Remembering Has a Price: Learning Memory Worth under Resource Constraints
Show answer and example
Answer: Similar memories may be long, obsolete, or unreliable. Under budget, compare actual task value. Stable base features supply interpretable signals, and RFM learns a query-dependent residual. The same value scale guides retrieval and retention. Feedback updates only memories actually selected and used; do not invent outcomes for unvisited entries.
Illustrative example: Example: Two memories concern the same interface. The old one is more similar but obsolete; the newer one is shorter and reliable, and may be worth retaining instead.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
Why separate fast residual fitting from slow feature-geometry updates?
Remembering Has a Price: Learning Memory Worth under Resource Constraints
Show answer and example
Answer: Fast updates fit value discrepancies from new feedback promptly. Slow updates use gradient statistics to adapt kernel-distance geometry without large representation swings after every observation. These are different adaptation timescales. The residual model cannot see all candidate outcomes; only used memory pairs have real labels.
Illustrative example: Example: One failure can lower a memory's residual worth. Multiple feedback observations can later change which feature differences the kernel amplifies.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Why can a newly admitted memory still be evicted immediately?
Remembering Has a Price: Learning Memory Worth under Resource Constraints
Show answer and example
Answer: Admission checks novelty or probe value relative to the best old memory. The expanded library then evicts the lowest overall value, and the new item competes too. Probes use real current and historical queries, not future test questions. Only selected pairs receive updates, not invented counterfactual success labels.
Illustrative example: Example: A sufficiently novel candidate enters a full library but ranks last by shared value. It should leave rather than force out a stronger existing memory.
Sections in the Chinese source: 核心公式, 本地复现与边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why are MemPrice's five representation levels a joint allocation problem?
MemPrice: Online Memory Allocation via Adaptive Pricing for Long-Horizon Agents
Show answer and example
Answer: Each memory can be full text, summary, abstraction, keywords, or deletion. These differ in size and usefulness and compete for one hard token budget. Independently picking the best version can exceed capacity. Optimize jointly while choosing at most one per item; deleted detail cannot be reconstructed from nothing in the current window.
Illustrative example: Example: One full-text memory can crowd out two summaries. Compare the whole group instead of choosing highest fidelity independently for every item.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why shouldn't an archive refresh reset the virtual queue and global round count?
MemPrice: Online Memory Allocation via Adaptive Pricing for Long-Horizon Agents
Show answer and example
Answer: The queue represents cumulative resource pressure, and the round count scales the dynamic price. Refresh only extracts a new representation from an external archive. Resetting both would forget past overuse and suddenly underprice detail. Hard capacity still applies every round; an average occupancy target cannot replace it.
Illustrative example: Example: After several nearly full context windows, a summary refresh should not zero the price and cause another wave of expensive full-text retention.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
How does dynamic pricing represent long-run capacity pressure that relevance Top-K misses?
MemPrice: Online Memory Allocation via Adaptive Pricing for Long-Horizon Agents
Show answer and example
Answer: Top-K uses only the current ranking. Dynamic price comes from a virtual queue of persistent occupancy, so historical overuse makes retaining detail more expensive. Hard capacity caps one round; average occupancy controls long-run pressure. They are not the same threshold, and the mechanism does not guarantee global optimality for all state paths.
Illustrative example: Example: Repeatedly filling the window raises the price and encourages lower fidelity. A currently relevant memory may no longer justify keeping a long original.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
How does MemPrice fit each memory's alternatives into a hard token budget?
MemPrice: Online Memory Allocation via Adaptive Pricing for Long-Horizon Agents
Show answer and example
Answer: Enumerate full text, summary, abstraction, keywords, and deletion, then measure sizes with the tokenizer. Use multiple-choice knapsack to choose at most one representation per memory. Each round must stay within B. The average occupancy target changes price, not whether the current window may exceed capacity. Archive refresh does not invent deleted detail.
Illustrative example: Example: With one hundred tokens left and two eighty-token originals, select summaries if useful instead of combining the independently best originals.
Sections in the Chinese source: 核心公式, 本地复现与边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why must MemoProAgent make one more judgment than ordinary QA when no user asks a question?
MemoProAgent: Toward Memory-Driven Proactive Assistance
Show answer and example
Answer: QA starts with a request. A proactive assistant must also decide whether to interrupt now, what to mention, and whether it has already said it. The paper combines long-term experience with current visual context to help at the right moment rather than maximize message count. Correct reminders can still fail through bad timing or repetition.
Illustrative example: Example: Reminding someone to bring keys before leaving can help. Repeating it three times after they already picked them up does not.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why does a proactive assistant need a separate intervention gate after retrieving relevant memories?
MemoProAgent: Toward Memory-Driven Proactive Assistance
Show answer and example
Answer: Relevance means topical overlap, not that interrupting now is warranted. The gate decides whether evidence merits intervention; the generator uses the current scene and prior speech to speak or stay silent. Timing and count matter, so correct but late or repeated reminders are not perfect success.
Illustrative example: Example: A nut allergy is relevant when the food is visible and the assistant has not warned yet. Repeating the warning creates a false trigger.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
Why do Perfect and a Hit for saying the right thing at least once measure different behavior?
MemoProAgent: Toward Memory-Driven Proactive Assistance
Show answer and example
Answer: Perfect requires correct content within the trigger window and exactly one utterance. Hit does not rule out early, late, or repeated interruption. Any speech on a silent negative segment is a false trigger. Raising recall alone can hurt user experience; content hits do not replace timing and count evaluation.
Illustrative example: Example: An early reminder followed by another inside the window can count as a hit without being a perfect intervention.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Can PPR retrieval and the semantic gate be replaced by one open-loop flag?
MemoProAgent: Toward Memory-Driven Proactive Assistance
Show answer and example
Answer: No. PPR performs actual personalized random walks with restart on entity relations. The gate decides whether the retrieved evidence warrants intervention. Training optimizes only generator tokens, not tool-injected evidence. A local fixture is not the official evaluation on authorized long videos and cannot use a flag to supply the right utterance.
Illustrative example: Example: Retrieving a relation between a cup and drinking habits still leaves the gate to determine whether the user just drank. The relation alone is not permission to speak.
Sections in the Chinese source: 核心公式, 本地复现与边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why does MemScope inspect raw trajectories, runtime memory, and provider code together?
MemScope: Evolving Agent Memory Architectures through Localized Code Repair
Show answer and example
Answer: The same failure can come from writing, retrieval, or use, which a total score cannot distinguish. Traces show actions, memory shows stored contents, and code explains the rules. Together they support a bounded repair. If evidence is insufficient, return no-patch rather than forcing edits every round.
Illustrative example: Example: A fact written but never retrieved requires a different fix than a fact never written. A wrong answer alone does not distinguish them.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why doesn't an unchanged memory-provider signature prove a patch is compatible with existing memories?
MemScope: Evolving Agent Memory Architectures through Localized Code Repair
Show answer and example
Answer: A signature constrains call shape, not internal field meanings or read/write semantics. MemScope combines raw traces, runtime memory, and code, patches in a bounded transaction, and probes real formats. Failure must preserve old code and memory; insufficient evidence can also mean no patch.
Illustrative example: Example: The parameter is still named memory, but a patch changes timestamps from seconds to days. Old records can be misread even though the code passes syntax checks.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
What is the trade-off between an in-place patch and regenerating the whole memory provider?
MemScope: Evolving Agent Memory Architectures through Localized Code Repair
Show answer and example
Answer: A local edit preserves provider identity and reduces compatibility and format drift. Keeping the interface still does not guarantee unchanged semantics, so run real probes. A full rewrite gives more freedom but can make old memory uninterpretable. Lines of code do not measure either strategy's effectiveness.
Illustrative example: Example: Adjusting a retrieval threshold can preserve stored records. Replacing the schema without migration may silently ignore them.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Why must replaceOnce match exactly once, and why allow no-patch when evidence is weak?
MemScope: Evolving Agent Memory Architectures through Localized Code Repair
Show answer and example
Answer: A local patch must identify the intended logic. Replacing arbitrary duplicate text can change the wrong behavior. replaceOnce requires a unique target and respects interface identity, syntax, and edit budgets. If localization or probe evidence is weak, do not submit a patch. Engineering validity alone is not semantic improvement.
Illustrative example: Example: Two sites have identical field reads. A patch specifying only that string cannot disambiguate them, so decline instead of changing the first match.
Sections in the Chinese source: 核心公式, 本地复现, 成本与边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why are storing every conversation and writing memories for future questions different tasks?
Hy-Memory-30B-A3B: Attributed Reinforcement Learning for Long-Term Memory Writing
Show answer and example
Answer: Raw conversations are large and later readers have limited context. A writer must preserve usable facts and relationships while controlling storage growth. Hy-Memory trains that policy rather than merely enlarging the archive. The useful test is whether later answers can be grounded in the resulting memory.
Illustrative example: Example: A discussion reschedules a meeting repeatedly. A later question needs the final date and its confirmation, not a mechanical archive of every repeated message.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why freeze the reader and judge before optimizing the memory writer?
Hy-Memory-30B-A3B: Attributed Reinforcement Learning for Long-Term Memory Writing
Show answer and example
Answer: Changing reader and judge together confounds better writing with stronger reading. Holding them fixed lets chunk probes and factual attribution isolate writer contributions; a storage-growth penalty prevents keeping everything. Each rollout gets one vote per chunk. More calls are not more independent evidence.
Illustrative example: Example: Give both writers' outputs to the same reader. Differences better reflect which facts were retained than whether one writer happened to get a stronger answer model.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
Why use both per-chunk probes and final outcome rewards?
Hy-Memory-30B-A3B: Attributed Reinforcement Learning for Long-Term Memory Writing
Show answer and example
Answer: Final answer feedback is sparse. Chunk probes give nearer signals about writing quality, and cross-chunk attribution estimates factual contributions. A growth penalty discourages storing everything. High local probe scores do not ensure cross-session answers, and a final outcome alone cannot identify the useful write.
Illustrative example: Example: An early chunk saves the right date, then a later chunk overwrites it incorrectly. Local probes and final attribution need to reveal the damage together.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Can multiple calls for the same chunk count as multiple reward votes?
Hy-Memory-30B-A3B: Attributed Reinforcement Learning for Long-Term Memory Writing
Show answer and example
Answer: No. Each rollout casts one vote per chunk, and advantages are normalized within chunk groups. Counting calls would give extra influence to more active trajectories. Gold stays with the judge, not writer, reader, or retrieval query. Large-scale writer RL was not run locally.
Illustrative example: Example: Five calls checking one chunk and one call in another rollout still contribute one vote each, not five versus one.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why are user commitments and constraints especially easy to lose when compressing long coding sessions?
Show answer and example
Answer: Large tool logs and discussions compete for context. Summaries can omit small but binding phrases or turn conditional requests into unconditional ones. Transparent compression marks what stays and what moves, with a path back to original materials, so continuation knows what is visible and what needs retrieval.
Illustrative example: Example: 'Submit only after confirming tests' summarized as 'prepare to submit' can make a later agent mistake conditional permission for unconditional authorization.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why are verbatim messages and omission markers more transparent than a fluent regenerated summary?
Show answer and example
Answer: Verbatim text preserves commitment wording. Omission markers identify what was moved out and provide a route back to the full conversation. This avoids silently turning guesses into facts. A recovery index does not mean the model found the evidence, and historical search can require paid subagent inference.
Illustrative example: Example: Summarizing 'do not deploy for now' without 'for now' changes the requirement. Keeping the original wording and marking removed tool logs makes the compression easier to audit.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
Why can't deterministic compression and model-subagent context_lookup both be called zero-call?
Show answer and example
Answer: Compression rules need no model, but semantic historical search uses a model subagent and has separate capability and cost. The local run restores exact IDs and checks hashes, not the paper's model retrieval. Fewer visible characters indicate a view change, not memory-QA ability or proportional total storage savings.
Illustrative example: Example: Reading a log by its known ID is model-free. Finding which commitment matters without an ID may need extra inference.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Why must Pi branch structure and tool metadata survive even when body text is removed?
Show answer and example
Answer: Read only ancestors of the chosen leaf so sibling histories cannot leak in. Tool pairing IDs, names, errors, and exit states preserve invocation semantics after body removal. A character cap evicts the oldest full blocks and leaves recovery markers, so the active context no longer contains every original statement.
Illustrative example: Example: Preserve isError=false rather than treating false as missing; otherwise later compression can lose proof the call succeeded.
Sections in the Chinese source: 核心公式, 本地复现, 代码映射与边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
What distinguishes a first-class composite capability from a stored formation history?
Recursive Formation and First-Class Reuse of Compositional Capabilities
Show answer and example
Answer: A first-class capability has its own type, public call ID, and execution semantics, so it is a candidate in later compositions. Formation history records how it was assembled and may require searching again. Direct reuse avoids formation work, but still runs recursive computation on the current input rather than caching an old answer.
Illustrative example: Example: Append 01 can become an ordinary operator by ID. It still appends both items to today's input, not returning yesterday's result.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why separate forming a composite capability from admitting it to a persistent skill library?
Recursive Formation and First-Class Reuse of Compositional Capabilities
Show answer and example
Answer: Compatible interfaces show that operations compose, not that the composition meets intended behavior. Independent validation gates admission. Persistent identity binds parents, types, and composition, while loading checks references and acyclicity. Later direct invocation saves search, not the real underlying computation.
Illustrative example: Example: Sorting then deduplicating can be wired together but may fail on empty input. Validate before storing it for direct reuse.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
What work does invoking an admitted composite save over expanding and searching again?
Recursive Formation and First-Class Reuse of Compositional Capabilities
Show answer and example
Answer: A first-class composite can participate as a typed operation with an identity, so later tasks do not repeat formation search. Expanding again must recover parent operations and wiring. Reuse saves search and assembly, while inner computation still runs. Count calls, formation attempts, and underlying work separately.
Illustrative example: Example: Reuse a learned filter-then-sort operation directly. Filtering and sorting still execute; skipping assembly does not make them free.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Why recheck the canonical hash, parent references, and acyclicity on cold load?
Recursive Formation and First-Class Reuse of Compositional Capabilities
Show answer and example
Answer: Persistent identity comes from canonical JSON of types, operations, and parent IDs. Files can be corrupted or tampered with. Complete parent references and acyclicity ensure legal recursion. True persistence testing destroys the old object and cold-loads the same snapshot. A local sequence-domain result is not general Lean or LLM capability.
Illustrative example: Example: A file can set its own ID as a parent without changing its name, creating a cycle. Keeping a live object in memory does not verify recovery from disk.
Sections in the Chinese source: 核心公式, 本地复现, 代码映射、验证与边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why store only lightweight metadata offline and build detailed memory at query time?
Show answer and example
Answer: What matters in a conversation depends on the question, and an offline summary can discard details too early. Event metadata retains lookup clues and raw links. SearchMeta, ReadRaw, and Answer build a query-specific cache at inference. Multiple accesses still cost work; this is not zero memory processing.
Illustrative example: Example: To answer an old travel-date question, find the event index and then read the source conversation rather than prewriting one universal summary.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why does ReadRaw only accept metadata IDs that have already been observed?
Show answer and example
Answer: Lightweight metadata provides traceable entry points. Reading raw text must bind to IDs actually returned, preventing fabricated links or access to unauthorized records. Memory builds for the current question through alternating search, reading, and answering. The metadata index is not fully understood memory and must not carry the final answer.
Illustrative example: Example: Search returns meeting M7, so ReadRaw can open its conversation. A model-invented M999 is not valid historical evidence.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
How does test-time memory construction differ from one retrieval with fixed context?
Show answer and example
Answer: One retrieval fixes evidence before later gaps are known. Test-time construction updates memory alongside information needs and can search or read more. This grants tool autonomy but can also waste steps; evaluate whether it improves real answers, not just action execution.
Illustrative example: Example: A meeting mentions rescheduling. Search for a subsequent event to confirm the new date instead of clinging to the date retrieved first.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
What state is managed by excluding seen entries in SearchMeta versus appending to the query cache?
Show answer and example
Answer: Seen entries record metadata IDs already returned and prevent duplicate results in this question. The cache accumulates useful material obtained for reasoning and answering. Raw conversations remain traceable external sources; the cache is not a prefilled answer. Separate states let you check whether search gains information and trace answer evidence.
Illustrative example: Example: Once meeting A's entry is seen, search should seek other events. Keep A's decision in the cache after reading it; skipping its entry does not erase evidence already read.
Sections in the Chinese source: 核心公式, 本地复现, 结果、验证与边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why is the actual clue harder to find when many memories discuss the same person or project?
NEAR: Neighborhood-Aware Residuals for Memory Retrieval
Show answer and example
Answer: Whole-record representations can be dominated by common topics. Frequent names make records similar and bury rare dates or events. NEAR uses neighborhood relations to emphasize distinctions and retrieve specific facts rather than repeatedly retrieving topical material.
Illustrative example: Example: Ten records mention project A, but only one says it moved to Thursday. A date question needs that difference, not more mentions of the name.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why might subtracting the neighbor mean direction help find memories with unique facts?
NEAR: Neighborhood-Aware Residuals for Memory Retrieval
Show answer and example
Answer: Neighbors often share names and topics, making irrelevant entries similar. Projecting out the shared direction highlights distinguishing residuals. Queries use a precomputed reference table, not relevance labels to choose a direction. Residuals can remove useful shared clues too, so retain the original view and choose fusion on development data.
Illustrative example: Example: Two records mention the same business trip, but only one says the return is Friday. Suppressing the common trip direction can make the return fact matter more.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
How do removing a shared direction and training a query-only adapter differ in their information sources?
NEAR: Neighborhood-Aware Residuals for Memory Retrieval
Show answer and example
Answer: NEAR constructs memory references, scales, and its small table only from memory states, with no query labels. A query gets its direction from the anchor table. Supervised adapters use training relevance to update query transforms. These are different information contracts; an unlabeled reference did not learn an answer-specific direction.
Illustrative example: Example: Memory neighborhoods can be built without query answers. Choosing a reference because it is the correct evidence would introduce supervision leakage.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Why not L2-normalize the whole concatenated vector after fusing layers?
NEAR: Neighborhood-Aware Residuals for Memory Retrieval
Show answer and example
Answer: Layer scores are scaled by memory–memory population variance and weighted. Concatenation coefficients make one dot product equal the fusion formula. Global normalization adds a sample-dependent denominator and changes ranking. Variance includes self-similarity, and neighborhoods are recomputed on normalized residuals at each layer rather than reused from layer one.
Illustrative example: Example: Two memories have different concatenated norms. Unit normalization penalizes the larger norm, so scores no longer equal the chosen linear combination.
Sections in the Chinese source: 核心公式, 本地复现, 代码映射与边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why can a pooled embedding miss a local fact in memory?
Beyond the Final Embedding: Retrieving Memories from Token-Level Evidence
Show answer and example
Answer: Pooling compresses several facts into one vector, so a date or object difference can be drowned out by a shared topic. Final-layer content tokens retain finer contextual evidence for sparse matching. A token match is not an independent dictionary meaning or guaranteed fact; combine it with the global branch.
Illustrative example: Example: Two records discuss travel, but only one sentence states a rebooking date. Their pooled vectors can be close while the local date token distinguishes them.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why is global token top-k followed by memory-ID aggregation different from per-memory MaxSim?
Beyond the Final Embedding: Retrieving Memories from Token-Level Evidence
Show answer and example
Answer: In global retrieval, tokens from all memories compete for a sparse return budget. MaxSim per record searches matches independently, changing computation and candidate distributions. Unreturned positions use a shared floor rather than true zero evidence. The pooled branch preserves overall meaning and can surface a memory without retrieved local tokens.
Illustrative example: Example: One record contains a rare date that strongly matches the question. Global token search can retrieve the date then its record without first ranking the pooled record highest.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
Which representations change with a query-only adapter versus retraining the memory encoder?
Beyond the Final Embedding: Retrieving Memories from Token-Level Evidence
Show answer and example
Answer: Query-only training freezes the encoder and memory bank and applies a low-rank residual to query content tokens, adapting them to existing geometry. Retraining the encoder can move both sides and require re-encoding old memory under a consistent version. The smaller update cannot restore information already lost in encoding.
Illustrative example: Example: Keep a million memory vectors fixed and adjust the query for who approved on Tuesday. Updating the shared encoder may require recomputing all old vectors.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Why doesn't the query adapter backpropagate through discrete neighbor selection?
Beyond the Final Embedding: Retrieving Memories from Token-Level Evidence
Show answer and example
Answer: Training uses multi-positive cross-entropy on all-memory MaxSim as a continuous surrogate; inference uses sparse token search. Discrete ANN selection does not supply a valid gradient. The low-rank residual adjusts only query content tokens while preserving norm. Encoder, memory bank, and pooled query stay frozen; validation alone chooses hyperparameters.
Illustrative example: Example: Top-K indices jump when a query changes, so they cannot be differentiated as a smooth function. Train on differentiable full matching, then use the sparse index at inference.
Sections in the Chinese source: 核心公式, 本地复现, 数据协议、结果与边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
How do nested intentions differ from an ordinary rolling summary?
Use and Disuse: Intent-Structured Experience Consolidation for Memory and Learning in LLM Agents
Show answer and example
Answer: Nested intentions organize current goals and subgoals. Experiences are abstracted when their intent closes, whereas rolling summaries compress primarily by time and need not know whether a task finished. Hippocam keeps an original-message tree and recalls one layer at a time, retaining traceability after abstraction.
Illustrative example: Example: Dependency checks can finish within an unresolved debugging goal. Summarize the closed subgoal without archiving the whole task as complete.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why does hierarchical recall return one layer at a time rather than immediately expanding all raw history?
Use and Disuse: Intent-Structured Experience Consolidation for Memory and Learning in LLM Agents
Show answer and example
Answer: Upper-level narratives give purpose and structure first, letting the agent drill down only when needed instead of refilling context each time. Original messages remain in child nodes, so abstraction is reversible. Reserve budget for the next turn and explicitly fail if protected complete exchanges still do not fit, rather than silently truncating them.
Illustrative example: Example: An upper node says login was repaired last week. Expand the log children only when checking the error, without returning every debug output.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
Why does it matter that Precip triggers after the response but before the tool result?
Use and Disuse: Intent-Structured Experience Consolidation for Memory and Learning in LLM Agents
Show answer and example
Answer: The placement lets the system process closed intentions from the completed main response without assuming an observation that has not arrived. Tool exchanges must remain complete; compression cannot split an unfinished call. Trigger timing is a state contract, not interchangeable with inserting a summary anywhere.
Illustrative example: Example: After a tool call is issued but before its result arrives, do not summarize it as a successful verification. Wait until the real observation enters a later exchange.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Do three archives in a controlled pressure probe show autonomous learning of intent closure?
Use and Disuse: Intent-Structured Experience Consolidation for Memory and Learning in LLM Agents
Show answer and example
Answer: No. Three real autonomous tasks produced no closure and zero archives. The separate controlled probe verifies pressure handling and protection only. Include request overhead and the next-turn estimate in budget. If protecting K complete exchanges and the dynamic window exceeds capacity, fail before main inference rather than truncate silently.
Illustrative example: Example: A predefined closure signal exercises Palim. It does not show that a model emits the signal on unknown tasks; report these runs separately.
Sections in the Chinese source: 核心公式, 本地复现, 验证与边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why do Mem++ non-destructive writes retain date and author?
Mem++: Non-Destructive Memory for Long-Term Organizational LLM Agents
Show answer and example
Answer: Original text carries facts, date supports as-of queries and version selection, and author preserves provenance and context. The write does not irreversibly rewrite records with a model, so later questions can reinterpret them. Raw storage does not guarantee retrieval and costs more storage and reads.
Illustrative example: Example: Keeping the dates and authors of two policy updates helps distinguish an older suggestion from a later official notice instead of blending them.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why filter by the question's time before reading instead of telling the model not to use future information afterward?
Mem++: Non-Destructive Memory for Long-Term Organizational LLM Agents
Show answer and example
Answer: Future documents can influence the model once they enter context, even with an instruction not to use them. Time eligibility first restricts lexical and semantic ranking to documents available then. Retaining verbatim text, date, and author aids audit but does not guarantee retrieval of the right record.
Illustrative example: Example: A March organizational decision cannot use an April announcement, however similar it is, as evidence of what was known in March.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
Why keep both lexical and semantic ranking in Mem++?
Mem++: Non-Destructive Memory for Long-Term Organizational LLM Agents
Show answer and example
Answer: Lexical retrieval is good for exact names, IDs, and quotations. Semantic retrieval handles paraphrases and vocabulary changes. Fusion uses both on time-eligible original records and cannot create missing facts. Returned evidence may overlap or conflict, so the final answer must verify contents and provenance.
Illustrative example: Example: A ticket number can hit lexically. A query about the last database outage may match a record saying storage service interruption semantically.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Did the local full-write and hybrid-retrieval test run OrgMemBench or an external embedding service?
Mem++: Non-Destructive Memory for Long-Term Organizational LLM Agents
Show answer and example
Answer: No. It runs verbatim retention, as-of filtering, and a reference lexical-semantic blend. Three seeds verify mechanism invariants. Organizational memory outcomes are the authors' benchmark; preset vectors and fixed records do not establish real assistant gains.
Illustrative example: Example: A future record being filtered verifies the date rule. Without real organizational QA and encoders, there is no comparable OrgMemBench capability score.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why measure a memory's effect on execution before cleaning up a library?
Causal Memory Policy: Making Memory Utility Identifiable by Intervening on Retrieval
Show answer and example
Answer: Memory takes context and may help, hinder, or be irrelevant. Deletion needs evidence of outcome utility. CMP makes utility estimable with retrieval-exposure experiments and retains uncertain items. It studies interventions under a fixed design, not frequency-based archiving.
Illustrative example: Example: Two old guides are both frequent. One helps recover from errors and the other repeats background. Outcome comparisons support keeping them differently.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why not delete a memory just because it often appears in failed tasks?
Causal Memory Policy: Making Memory Utility Identifiable by Intervening on Retrieval
Show answer and example
Answer: Hard tasks can preferentially retrieve that memory, biasing the correlation. Balanced randomized exposure gives comparable treatment and control observations, and standard errors protect uncertain items. Replacing one entry in fixed slots changes exposure of others, so the effect is specific to the design rather than universally additive.
Illustrative example: Example: A manual used in the hardest incidents can have low success because incidents are difficult. Randomized exposure helps test whether the manual itself hurts.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
How does protecting uncertain memories differ from deleting any with a negative estimated mean?
Causal Memory Policy: Making Memory Utility Identifiable by Intervening on Retrieval
Show answer and example
Answer: With high variance and few samples, a negative mean can conceal a positive effect. CMP combines standard errors with asymmetric deletion cost, refuses estimates with inadequate support, and returns noop under infinite uncertainty. One negative outcome is not permanent forgetting.
Illustrative example: Example: Two treatment runs that happen to fail are insufficient to prove harm. Wide uncertainty calls for retention or more evidence.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Why do fixed k exposure slots prevent interpreting effects as independent additive coefficients?
Causal Memory Policy: Making Memory Utility Identifiable by Intervening on Retrieval
Show answer and example
Answer: Exposing one more memory changes the others' distribution inside fixed slots. The measured effect includes replacement under the randomized design. Each row has k entries, column exposures are roughly balanced, and each arm needs at least two observations. Recovering synthetic utilities is not a long-term cross-query policy or real QA accuracy.
Illustrative example: Example: In two slots, adding A displaces another candidate. The result measures the net effect of A replacing some content, not A's isolated contribution.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why does explicit belief track both facts and unresolved requirements?
Beyond Memory: Harnessing Long-Horizon Agents with Explicit Belief States
Show answer and example
Answer: Facts describe the currently believed world; unresolved requirements describe what the task still lacks. History text alone can mask repeated work as progress. An explicit set supports stall detection, but entries need evidence before removal.
Illustrative example: Example: The user's address is known, while inventory is unconfirmed. Rereading the address does not resolve inventory.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why do explicit unresolved requirements detect stalls more easily than a history summary?
Beyond Memory: Harnessing Long-Horizon Agents with Explicit Belief States
Show answer and example
Answer: A summary describes work done. Unresolved requirements make progress comparable. If successive actions do not reduce them, the agent may be cycling and can recover around the specific gap. Action count is not progress. Facts and requirements must update from actual observations, not confidence.
Illustrative example: Example: Five searches still have not verified a date. The unresolved item exposes that activity did not move the goal forward.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
How does Belief Trapping differ from checking for repeated actions?
Beyond Memory: Harnessing Long-Horizon Agents with Explicit Belief States
Show answer and example
Answer: Action repetition checks surface behavior. Belief stalling checks whether unresolved requirements decrease. Different actions can circle the same bad assumption, and the same query may help after a state change. Diagnose progress from facts and requirements, not action strings alone.
Illustrative example: Example: Three search phrases fail to confirm payment despite different wording. Checking again after a transaction settles may actually make progress.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Does Δ|unresolved|≥0 prove a task is unsolvable?
Beyond Memory: Harnessing Long-Horizon Agents with Explicit Belief States
Show answer and example
Answer: No. It means that the window did not reduce outstanding requirements. Necessary preparation, missing evidence, or a bad updater can cause it. Trigger targeted recovery rather than declaring unsatisfiability. The local run tests belief updates and stall detection without external tools or learned extraction; rule activation is not long-horizon success.
Illustrative example: Example: Preparing identity verification may leave requirements unchanged but enable the next query. Stopping immediately would cut off a legal path.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why shouldn't a long-horizon coding agent wait until context is full before considering compression?
AutoCompact: Learning When to Compact Context in Long-Horizon Coding Agents
Show answer and example
Answer: Work includes pending edits, test feedback, and delivery requirements. Bad timing can discard precisely what the next step needs. AutoCompact learns when to compress and how to continue, aiming for task continuity under context pressure rather than shorter text alone.
Illustrative example: Example: Forced compression just after a failing test appears may drop the key error before its cause is recorded. Choose timing with task progress in mind.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why should a judge correct compression timing, summary content, and next action together?
AutoCompact: Learning When to Compact Context in Long-Horizon Coding Agents
Show answer and example
Answer: These decisions interact. Early compression can lose evidence, missing facts can induce bad actions, and later behavior can squander a correct summary. Executing the corrected tuple lets training observe joint consequences. Summary fluency alone cannot establish sufficiency for long-horizon coding.
Illustrative example: Example: A clear summary omitting a parameter constraint can cause the next edit to break an interface. Correct both memory and action.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
What is the trade-off between learned compression timing and a fixed length threshold?
AutoCompact: Learning When to Compact Context in Long-Horizon Coding Agents
Show answer and example
Answer: A fixed threshold responds only to capacity and cannot distinguish moments with fragile commitments or unfinished work. A learned decision can use task state but requires reliable supervision and can err. Evaluate actual downstream coding results and cost alongside context reduction.
Illustrative example: Example: Compression just after a tool return and before recording its conclusion is risky. Waiting until state is clear can preserve what matters.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
After a judge corrects the tuple, should the environment execute the original action or the corrected one?
AutoCompact: Learning When to Compact Context in Long-Horizon Coding Agents
Show answer and example
Answer: Execute the corrected decision, summary, and action together so training records match consequences. SFT plus outcome RL needs real execution feedback. The local run verifies the three-field in-place correction contract without training a coding agent or running SWE containers. Field checks are not code-repair results.
Illustrative example: Example: If the judge changes 'submit now' to 'run the failing test first,' executing the old submit action makes its reward invalid evidence for the corrected policy.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why does MemFit focus on write costs for high-frequency conversations?
MemFit: Efficient Long-Term Agentic Memory
Show answer and example
Answer: A long-lived assistant continually receives turns. Rewriting all memory with a costly model on every turn incurs cost before retrieval and can erase details. MemFit keeps writes lightweight and originals traceable, moving query-specific filtering to reads while facing the growing index size.
Illustrative example: Example: A support system gains hundreds of turns per day, many never queried. Complex semantic rewriting of each turn can cost more than useful future queries.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why store append-only raw turns separately from searchable segment summaries?
MemFit: Efficient Long-Term Agentic Memory
Show answer and example
Answer: Summaries make compact indexes but can omit details. Keeping raw records unchanged gives later close reading traceable evidence. Writes avoid expensive model rewrites of all history; reads combine lexical, semantic, and reranking signals. An index hit is only an entry point, and an omitted summary detail may still exist.
Illustrative example: Example: A segment summary says payment API discussion. Read the original turn to find the exact timeout; keeping only the summary might lose it permanently.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
What does inexpensive append-only writing trade off against LLM memory rewriting every turn?
MemFit: Efficient Long-Term Agentic Memory
Show answer and example
Answer: Append-only avoids repeated generation and irreversible rewriting, but raw storage grows and retrieval and indexing do more filtering. LLM writes can abstract early but lose details. Compare writing, storage, and final retrieval quality together, not just call counts in one stage.
Illustrative example: Example: Saving a thousand raw turns is cheap, but a later query must quickly locate one address change. Inexpensive writes do not guarantee cheap reads.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Does the local hybrid retrieval hook mean embedding and cross-encoder inference ran?
MemFit: Efficient Long-Term Agentic Memory
Show answer and example
Answer: No. The hook accepts lexical, semantic, and reranking signals but does not call a real embedder or cross-encoder. It tests append-only behavior and score combination. Fixture semantic scores cannot establish real long-conversation retrieval quality or paper latency.
Illustrative example: Example: Correctly sorting three records with preset semantic scores tests fusion, not whether a model derives reliable scores from natural language.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why does UpliftMem distinguish relevant retrieval from helping the agent complete a task?
UpliftMem: Learning Set-Level Uplift for Agent Memory Retrieval
Show answer and example
Answer: Similar memories can duplicate what is known or conflict with other records. Relevance scores need not measure execution value. UpliftMem asks whether a complete set gives a fixed executor additional benefit, reserving context for evidence combinations that change outcomes.
Illustrative example: Example: Three high-similarity records give the right API name but omit authentication. The task still fails, so similarity alone does not establish utility.
Sections in the Chinese source: 背景与主要改动. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why isn't the utility of a memory set the sum of individual relevance scores?
UpliftMem: Learning Set-Level Uplift for Agent Memory Retrieval
Show answer and example
Answer: Items can complement, duplicate, or conflict, so set-level execution effects are not additive relevance. The method supervises on the difference with and without memory for the same frozen executor. Additional rollouts go where they can change the local choice. Relevance proposes candidates, not measured uplift.
Illustrative example: Example: One item gives an API name and another its argument constraints; together they enable execution. Two similar copies of the API introduction may be less useful.
Sections in the Chinese source: 背景与主要改动. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
How does EVSI allocation differ from giving each candidate the same number of extra rollouts?
UpliftMem: Learning Set-Level Uplift for Agent Memory Retrieval
Show answer and example
Answer: Uniform allocation ignores whether uncertainty can change the selection. EVSI asks how much an observation is expected to change the local retrieval decision. A correlated Gaussian posterior expresses candidate dependencies. This allocates budget; the highest predicted mean is not observed success.
Illustrative example: Example: Extra probing is low-value when two sets are far apart. A rollout can be more useful for two close, uncertain alternatives.
Sections in the Chinese source: 背景与主要改动. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Why does set_level_uplift require paired treatment and control?
UpliftMem: Learning Set-Level Uplift for Agent Memory Retrieval
Show answer and example
Answer: Compare memory versus no memory on the same task, frozen executor, and matched conditions to reduce task and model confounds. The local run implements paired differences and EVSI on a fixed posterior, not full set construction, shared scoring, or real execution. Component outputs are not agent success gains.
Illustrative example: Example: A memory set on a hard problem versus no memory on an easy one is not comparable. Both conditions must face the same instance.
Sections in the Chinese source: 本地复现. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why are the input challenges of long-context recommendation agents broader than long history?
ReMem: Rethinking Perception and Memory in Long-Context Recommendation Agents
Show answer and example
Answer: The agent must understand heterogeneous item pages and track preferences through accumulating user behavior. Errors on either side can lead to poor recommendations. ReMem studies perception and evolving memory together to provide enough decision evidence within a fixed budget, not simply add history.
Illustrative example: Example: Product weight is embedded in an image and the user now prefers light items. Shorter chat history alone neither reads the weight nor guarantees an updated preference.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why improve both item perception and bounded memory in a recommendation agent instead of only shortening history?
ReMem: Rethinking Perception and Memory in Long-Context Recommendation Agents
Show answer and example
Answer: Bad page extraction makes even a sophisticated preference memory retain wrong semantics. OCR perception first produces compact item representations, then dynamic memory updates preferences under budget. Several memory views share policy training while supplying distinct evidence. Test preference answers must never be injected to create apparent gains.
Illustrative example: Example: A price in small print on an image cannot be corrected by compressing browsing history. Extract reliable attributes first, then retain information relevant to the user's budget.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
What is the trade-off between dynamic fixed-budget memory and full history?
ReMem: Rethinking Perception and Memory in Long-Context Recommendation Agents
Show answer and example
Answer: Full history retains more but costs grow with interactions. Dynamic memory ranks by relevance and recency and emphasizes current preferences within budget, at the risk of losing rare important constraints. Recent observations do not replace auditing long-term facts, and real user episodes are needed to measure recommendation quality.
Illustrative example: Example: Recent running-shoe purchases should not erase a longstanding material allergy. Verify the constraint survived compression.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Why can't Multi-Memory GRPO mix all memory views into one advantage group?
ReMem: Rethinking Perception and Memory in Long-Context Recommendation Agents
Show answer and example
Answer: Normalize rewards separately within each memory view for the same query, then share the clipped policy update. Mixing views can confuse differences in view difficulty with action advantage. The local run tests budget, temporal updates, and objectives, not OCR, browsers, or real recommendation episodes.
Illustrative example: Example: Sparse views may have lower rewards overall. Mixing them with rich views can wrongly attribute that difficulty to particular responses.
Sections in the Chinese source: 核心公式, 本地复现与边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why is a context file part of model behavior rather than a fixed external summary?
Show answer and example
Answer: The model chooses what to keep, delete, and reorganize; later actions read the edited state. In a fixed harness, external rules choose what and when to compress. Model editing changes responsibility and risks losing important constraints, so capacity and execution contracts still matter.
Illustrative example: Example: Delete an obsolete log and keep its conclusion proactively instead of waiting for a length threshold to summarize all history.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why does letting a model edit a context file also change KV reuse cost?
Show answer and example
Answer: The file prefix determines whether cached representations still match. Changing early tokens usually requires re-prefilling the suffix. File transforms therefore determine both what to remember and future runtime cost. Shorter text is not always cheaper when it invalidates a large cache.
Illustrative example: Example: Appending an observation at the end can preserve prefix KV. Rewriting the opening summary can force recomputation despite fewer total words.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
How do context editing and direct KV eviction differ in what logical history remains?
Show answer and example
Answer: File edits change the logical token sequence the model sees and require prefix matching before reuse. Direct KV eviction can retain logical text while changing active cache state. Reducing active context in both cases does not imply the same cache identity or recovery semantics.
Illustrative example: Example: Deleting early file text changes the prefix for all later tokens, so the old full KV cannot be copied. Dropping KV alone can leave the text intact.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Why must suffix cache reuse recompute from the first token mismatch?
Show answer and example
Answer: Causal hidden states depend on earlier tokens. After the first mismatch, later identical text can still have different KV. Keep only the longest common prefix and check file capacity explicitly. The local run tests edits and boundaries without CLM training or a long multi-agent swarm.
Illustrative example: Example: Changing token 100 can alter token 101 and all following states, not just the replaced position.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why does Mnemon keep dated originals but give the answering model only a small view?
Mnemon: Raw Records, Fast Judgments, Slow Thoughts
Show answer and example
Answer: Originals retain checkable details and dates. A small view gives relevant evidence within budget instead of replaying all history. Slow planning proposes searches and fast Jev decisions select records. Missing facts may require further lookup; the view is not a lossless summary.
Illustrative example: Example: Pick a few dated rescheduling events from years of records rather than resend all chats to answer when the latest change happened.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why separate slow search planning from fast record decisions instead of reasoning at length about every record?
Mnemon: Raw Records, Fast Judgments, Slow Thoughts
Show answer and example
Answer: Planning chooses where to seek evidence; per-record eligibility fits a bounded fast decision. Separation spends reasoning budget on search direction rather than repeatedly explaining candidates. Dated originals remain, while the answerer sees a small budgeted view. Fast decisions do not guarantee complete evidence or correct time eligibility.
Illustrative example: Example: Decide to search a release meeting, quickly screen dozens of records, then send a few originals to the answerer instead of analyzing every record at length.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
How do dated raw records compare with repeatedly rewriting one long-term summary for traceability?
Mnemon: Raw Records, Fast Judgments, Slow Thoughts
Show answer and example
Answer: Raw records retain exact wording, time, and details for different questions, but cost storage and query-time reading. A rolling summary is compact yet can erase provenance or rare facts. Mnemon builds a budgeted view from originals for this query, not a permanent lossless replacement.
Illustrative example: Example: A summary says the customer prefers A, while the dated email says only this quarter. Check the original before answering about next quarter.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Does the local bounded-view test cover Jev semantic judgments and the original answer model?
Mnemon: Raw Records, Fast Judgments, Slow Thoughts
Show answer and example
Answer: No. It runs raw-record retrieval and budgeted view construction without a Jev checkpoint or reproducing LoCoMo scores. Record order, dates, and budget are independently checkable. Real models are needed to test semantic necessity and whether the answerer uses evidence correctly.
Illustrative example: Example: Fitting three specified records verifies the view interface, not that the judge selects them from natural language.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
What kind of context growth is CCM trying to avoid across many turns?
Show answer and example
Answer: Resending every observation, action, and thought grows cumulative input and can bury current state. CCM lets the agent maintain bounded memory each turn and keep acting. It studies how to compress the past into decision-sufficient state rather than retain complete history indefinitely.
Illustrative example: Example: At step ninety, current files, verified results, and pending work may suffice without every terminal output from the previous 89 steps.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
If the training teacher sees full history, why can the next student turn see only bounded memory?
Show answer and example
Answer: Privileged history supplies training signals, while the deployed student still sees the task, memory, and latest observation. This forces it to write necessary state into limited space. Providing full history at evaluation bypasses continuous management. Memory updates accompany actions and must serve the next decision.
Illustrative example: Example: A teacher knows a port number mentioned earlier. The student must preserve it in small memory rather than receive the whole earlier conversation on test.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
How does per-turn bounded state differ from retrieving a few old records just before answering?
Show answer and example
Answer: CCM updates memory during each action, so retention now determines next-turn visibility. Answer-time retrieval makes the main selection later using an external index. The bottlenecks differ and can complement each other. Bounded-state omissions cannot rely on hidden history, and retrieval must count indexing and reads.
Illustrative example: Example: A terminal changes directories. CCM should immediately keep the path; later retrieving an old command alone may miss the directory change.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
How do you check that CCM does not bypass bounded context with unrecorded history?
Show answer and example
Answer: Inspect that each policy request contains only the original task, current memory, and latest observation. Prior tool results are visible only if written into memory, which has a hard cap. The local run tests these contracts without TerminalBench or WebShop checkpoints; field isolation is not task capability.
Illustrative example: Example: Hiding a full previous transcript in an extra metadata field violates the contract even if the main prompt is shorter.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why is it hard for a cross-session assistant to know on day one what will matter on day three?
Interactive Memory Learning for Long-Term Conversations
Show answer and example
Answer: Future requests have not occurred. The writer chooses likely durable facts from observed conversation, and the reader retrieves them in suitable contexts. Interactive Memory learns from actual future usefulness rather than giving the writer future questions.
Illustrative example: Example: A user casually mentions avoiding peanuts on day one and asks for meal planning on day three. The value of that note becomes evident later.
Sections in the Chinese source: 背景与主要改动, 核心公式与实现对应. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why jointly learn a write Planner and read Trigger from delayed cross-session reward?
Interactive Memory Learning for Long-Term Conversations
Show answer and example
Answer: Some details reveal their usefulness only in later sessions. Retrieval timing determines whether they affect results. Shared delayed reward links writing to later use instead of rewarding summary quality alone. Evaluate in chronological order; future questions must not preselect what to write.
Illustrative example: Example: Saving a changed workplace matters for commute planning next week. Same-day chat fluency may never reward saving it.
Sections in the Chinese source: 背景与主要改动, 核心公式与实现对应. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
How does delayed cross-session reward differ from reward based on per-turn retrieval similarity?
Interactive Memory Learning for Long-Term Conversations
Show answer and example
Answer: Similarity is an immediate proxy that may not predict later use. Delayed reward observes later dialogue outcomes to learn long-term writing and trigger value. It introduces credit assignment; revealing future questions to the writer would no longer test learning for an unknown future.
Illustrative example: Example: An allergy detail may be unrelated to the present topic yet crucial for ordering later. Similarity can underestimate that long-term value.
Sections in the Chinese source: 背景与主要改动, 核心公式与实现对应. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Why distinguish information available at writing time from later evaluation in an observation-safe state machine?
Interactive Memory Learning for Long-Term Conversations
Show answer and example
Answer: The writer sees observations available then. Future questions, answers, and scores can supply external reward only after the corresponding execution. Local Planner/Trigger diagnostics verify isolation and feedback, not paper-scale training or learned preferences from preset fixture rewards.
Illustrative example: Example: Hiding day three's question in day one's write input makes fact selection easy, but this lookahead leak invalidates the learning claim.
Sections in the Chinese source: 核心公式与实现对应, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why can GUI skills become invalid as interfaces and tasks change?
Reflect, Revise, Reuse: Training-Free Skill Evolution for GUI Agents
Show answer and example
Answer: Button positions, page sequence, and preconditions can change. A skill that worked before need not execute in a new state. EvoSkill-GUI studies converting observed failures into verified improvements for later reuse. Training-free still requires real observations and execution checks.
Illustrative example: Example: A top-right button moves into a menu. Replaying the old trace fails, so revise the corresponding step from the current screen.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why is changing only the responsible GUI skill component more auditable than regenerating the whole skill?
Reflect, Revise, Reuse: Training-Free Skill Evolution for GUI Agents
Show answer and example
Answer: A local edit ties failure evidence to one component and preserves other verified behaviors. This makes it easier to tell whether the patch fixed the defect without broad drift. A critic needs information isolation, not hidden answers. Verify the revised skill before reusing it elsewhere.
Illustrative example: Example: If login fails only when closing a pop-up, first fix that locator rather than rewrite username entry and submission too.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
How does local revision by an isolated critic differ from ad hoc self-editing by the executor?
Reflect, Revise, Reuse: Training-Free Skill Evolution for GUI Agents
Show answer and example
Answer: The critic independently attributes failure from permitted evidence, limits patch scope, and verifies before reuse. Ad hoc edits can carry over the executor's wrong assumptions. Isolation controls evidence and responsibility rather than guaranteeing correctness; retain failure evidence and validation results.
Illustrative example: Example: The executor assumes a page finished loading. A critic can identify a missing wait from observations instead of accepting that the button is absent.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Can the local public-observation patch demo establish cross-task reuse on real GUIs?
Reflect, Revise, Reuse: Training-Free Skill Evolution for GUI Agents
Show answer and example
Answer: No. It reads public evidence and applies bounded reference edits without MobileWorld, AndroidWorld, or OSWorld. It verifies no gold access, patch scope, and state transitions. Real screen understanding, clicking, and validated cross-task success remain unestablished.
Illustrative example: Example: Updating a locator after a button name changes in a string verifies the patch contract, not finding that button in an actual screenshot.
Sections in the Chinese source: 核心公式, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why evaluate both new skills and existing user needs when training skill retrieval?
When Synthetic Data Hurts: On Catastrophic Forgetting in Skill Retrieval for LLM Agents
Show answer and example
Answer: New data adapts the retriever to a larger skill catalog, but service still receives familiar real and out-of-domain queries. The goal is retaining old routing while learning new material, not only minimizing loss on new data. Improvements on new tasks do not erase the cost of forgetting existing usage.
Illustrative example: Example: A model works on synthetic examples with canonical function names, but users still describe their needs colloquially. Those queries are not obsolete.
Sections in the Chinese source: 背景与主要改动, 核心公式或操作. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why might more synthetic skill data hurt retrieval on real tasks?
When Synthetic Data Hurts: On Catastrophic Forgetting in Skill Retrieval for LLM Agents
Show answer and example
Answer: Synthetic language and distributions can differ from real requests, shifting embeddings and routing boundaries toward synthetic patterns. Replay preserves real task coverage; anchoring or distillation from an old model limits drift. These protect transfer and retention, not a guarantee that more synthetic data helps or forgetting disappears.
Illustrative example: Example: Synthetic requests always spell out tool names, while real users use abbreviations. Training only on synthetic wording may miss real requests; replaying abbreviations preserves old routing.
Sections in the Chinese source: 背景与主要改动, 核心公式或操作. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
What do real-data replay and embedding anchors or LwF constrain differently?
When Synthetic Data Hurts: On Catastrophic Forgetting in Skill Retrieval for LLM Agents
Show answer and example
Answer: Replay exposes optimization to old tasks; anchors or Learning without Forgetting limit representation or output drift. One provides data coverage and the other constrains behavioral changes induced by updates. They are complementary, not redundant. Too much weight can inhibit new skill learning, so validate the trade-off.
Illustrative example: Example: Replay old colloquial requests and separately constrain their embeddings not to move far. That protects old retrieval through both examples and representation.
Sections in the Chinese source: 背景与主要改动, 核心公式或操作. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Does passing local anchor, conflict penalty, and replay checks include training the 0.6B retriever?
When Synthetic Data Hurts: On Catastrophic Forgetting in Skill Retrieval for LLM Agents
Show answer and example
Answer: No. The local reference runs route anchors and associated constraints without training the 0.6B model over more than thirty thousand skills. It checks replay participation, anchor-loss direction, and conflict handling. Synthetic state changes do not establish real or OOD retrieval retention.
Illustrative example: Example: Pulling one vector toward its old anchor verifies the gradient, not correct skill retrieval for unseen wording.
Sections in the Chinese source: 核心公式或操作, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why can't an enterprise agent treat a guess after one execution as long-term knowledge?
Grounding Agent Memory: Environment-Probing Curation for Enterprise Agents
Show answer and example
Answer: Permissions, configuration, and interfaces change, and one failure may be temporary. Grounded Memory requires traceable environmental evidence and a scope before persisting experience. Recording what happened is only part of knowing where and when it holds.
Illustrative example: Example: A repository access failure today does not mean the service is permanently unavailable. A durable conclusion needs clearer state evidence.
Sections in the Chinese source: 背景与主要改动, 核心公式或操作. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why should a memory curator probe the environment with least-privilege read-only tools before writing?
Grounding Agent Memory: Environment-Probing Curation for Enterprise Agents
Show answer and example
Answer: Conversation claims may be stale or environment-specific. Probing ties candidate memory to current observable facts and scope. Read-only least privilege avoids changing the observed system. A verified claim holds under those conditions, not permanently or everywhere.
Illustrative example: Example: A claim that the server runs on port eight thousand can be checked in read-only configuration and scoped to that environment. Do not edit the config to make it true.
Sections in the Chinese source: 背景与主要改动, 核心公式或操作. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
How does admission by environment probing differ from direct LLM summarization of experience?
Grounding Agent Memory: Environment-Probing Curation for Enterprise Agents
Show answer and example
Answer: Summarization relies on trace text and can turn guesses into facts. Independent probes can reject contradictions and narrow scope, but add query and maintenance cost and can verify only observable conditions. A verification step does not make every enterprise state reliable.
Illustrative example: Example: A missing path in one repository should not become a claim about all projects. A probe can scope it to the current repository and revision.
Sections in the Chinese source: 背景与主要改动, 核心公式或操作. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Why must a curator not turn a least-privilege read-only tool into a repair action?
Grounding Agent Memory: Environment-Probing Curation for Enterprise Agents
Show answer and example
Answer: The curator verifies candidate memory. Writing changes the state it is trying to observe and introduces side effects. Local tests cover repeated probing, conflict rejection, and admission, not Copilot SDK integration. Passing call contracts does not reproduce enterprise agent costs or outcomes.
Illustrative example: Example: If a value differs, update the memory's evidence rather than editing live configuration back to the old value and calling the old memory verified.
Sections in the Chinese source: 核心公式或操作, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why must long-term memory support both an overview and a return to specific events?
MemForest: Efficient Agent Memory Management via EventTree Partitioning and Progressive Merging
Show answer and example
Answer: Reading all raw history costs too much, but a single summary can omit the source of a decision. MemForest keeps events locally structured and progressively compresses under capacity pressure while preserving paths back to evidence. It balances scale with traceable detail.
Illustrative example: Example: Finding which meeting changed a plan last month requires both its event cluster and the actual confirmation message.
Sections in the Chinese source: 背景与主要改动. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why do progressively merged event trees help locate evidence better than repeatedly rewriting a global summary under pressure?
MemForest: Efficient Agent Memory Management via EventTree Partitioning and Progressive Merging
Show answer and example
Answer: Event partitions preserve local time and causal structure. Merge only necessary nodes rather than disturbing all history. Queries propagate from semantic anchors through neighborhood links, including cross-event relations. Hierarchical summaries can still lose details; trees control loss and lookup paths without guaranteeing losslessness.
Illustrative example: Example: A failed payment and later refund are separate events linked across trees. Rewriting one global summary may blur their order.
Sections in the Chinese source: 背景与主要改动. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
How does semantic-anchor neighborhood propagation differ from retrieving only the most similar node?
MemForest: Efficient Agent Memory Management via EventTree Partitioning and Progressive Merging
Show answer and example
Answer: A single match may be superficially related. Propagation can add context via temporal and cross-event links. This structure expands evidence but can also add noise, so control propagation range and budget. Neighboring nodes are not automatically correct evidence.
Illustrative example: Example: After matching a rescheduling proposal, read the neighboring confirmation to learn whether the new date took effect.
Sections in the Chinese source: 背景与主要改动. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Where does the local token-Jaccard EventTree stop short of the paper's embeddings and LLM summarizer?
MemForest: Efficient Agent Memory Management via EventTree Partitioning and Progressive Merging
Show answer and example
Answer: Local CPU structures select trees by term Jaccard and run compression, checking partitioning and merging. They do not run author embeddings, an LLM summarizer, or long-horizon benchmarks. Structural correctness and fewer records do not establish semantic retrieval or QA capability.
Illustrative example: Example: Two nodes sharing meeting can match by Jaccard. Whether they describe the same event requires richer semantics not proved by this interface.
Sections in the Chinese source: 本地复现与边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why is CoSkill's Meta-Skill Agent a learnable policy rather than a fixed script?
Show answer and example
Answer: It edits skill contents based on execution returns. The Reasoning Agent learns to select and use task and substep skills. Roles share a backbone and update alternately, adapting the library and action policy together. Verify that edits improve actual execution before keeping them.
Illustrative example: Example: When the reasoning role finds a missing recovery step, Meta-Skill proposes a change and validates after resetting the environment instead of permanently saving every reflection.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why can shared team reward adapt both the reasoning and Meta-Skill policies?
Show answer and example
Answer: Skill content determines available procedures, and reasoning choices determine which skills get execution feedback. A joint objective connects both to task results; alternating updates reduces the risk of a revised library being unused or a revised policy being limited by old skills. Shared reward does not solve credit assignment for each edit.
Illustrative example: Example: If a long skill fails, Meta-Skill can shorten it while the reasoning agent learns when to invoke the revision instead of merely storing a new document.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
How does joint training differ from training retrieval over a fixed skill library?
Show answer and example
Answer: A fixed library changes only what is selected. Joint training also changes skill contents that may not suit the task, increasing nonstationarity and attribution difficulty. Role credit, isolated edits, and rejecting non-improving updates matter; library growth does not imply stronger teamwork.
Illustrative example: Example: Better retrieval cannot fix steps in the wrong order. Meta-Skill can fix the order, but must check other tasks for regressions.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
How should actual updates across three local seeds without promotion be interpreted?
Show answer and example
Answer: Both roles had nonzero gradients and parameter changes, but reset validation showed no positive gain. The skill candidate was not promoted and the baseline champion stayed. Old results that read evaluation labels are void, and legacy parsing is not capability. Local Qwen ToolRoute is not comparable with paper ALFWorld/WebShop scores.
Illustrative example: Example: Large parameter movement without validation gain proves execution and rejection work, not that CoSkill improves success.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why does a recommendation assistant need user memory that tracks changes and evidence?
AtomRec: Evolving Atomic Memory for Agentic Recommendation
Show answer and example
Answer: Behavior reflects long-term preferences, short-term intent, and item-specific feedback. A fixed profile is hard to update or explain. AtomRec evolves evidence at a fine granularity and uses history relations to explain candidates. A single click need not imply long-term preference, so retain context and provenance.
Illustrative example: Example: A gift perfume purchase should not make the system infer that the user personally prefers that scent long term.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why does an atomic user profile help keep new preferences from overwriting old ones?
AtomRec: Evolving Atomic Memory for Agentic Recommendation
Show answer and example
Answer: Updates touch matching fact fields without rewriting the whole profile, reducing incidental deletions or semantic drift. Semantic collaborative edges and multi-hop paths connect recommendation evidence separately from preference values. Atomic fields still require conflict and time handling; old facts are not automatically permanent.
Illustrative example: Example: A new no-spicy-dinner preference changes that field only, preserving commute budget and breakfast preferences.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
How does a multi-hop evidence path differ from one collaborative user–item edge?
AtomRec: Evolving Atomic Memory for Agentic Recommendation
Show answer and example
Answer: A direct edge gives overall association. A multi-hop path can trace preference through a historical item attribute to a candidate. Semantic edges may still be wrong, so reachability is not causal proof of preference. Evaluate downstream ranking on a closed candidate set with target isolation.
Illustrative example: Example: Linking the lightweight attribute of previously liked shoes to a new pair is more traceable than saying they are often bought together, if the attribute link is grounded in actual history.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
What do local pre-target reconstruction and zeroing illegal links prevent?
AtomRec: Evolving Atomic Memory for Agentic Recommendation
Show answer and example
Answer: Rebuild memory from history strictly before each held-out target to prevent future behavior leakage. Generated links can cite only provided historical IDs; malformed or illegal output fails without reference-answer backfill. The small local test is negative, so executed data flow is not a recommendation or online gain.
Illustrative example: Example: Seeing the target product in later history makes the task easier. Remove it in the time-correct reconstruction, not just hide the prompt field name.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why is a pseudo skill a retrieval proxy rather than a verified procedure?
Imagine Before Acting: Prospective Skill Identification for LLM Agents
Show answer and example
Answer: The model imagines capabilities and procedure-like descriptions to bridge task wording and skill documents. These descriptions have not been executed and may omit steps or violate conditions. Load and validate the real procedure before acting; a complete-looking description is not proof.
Illustrative example: Example: A pseudo skill says export and verify files in bulk. It helps find the export skill, but real parameters, permissions, and checks come from the actual documentation.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
After generating a pseudo skill, why does CSI recheck capability fit before execution?
Imagine Before Acting: Prospective Skill Identification for LLM Agents
Show answer and example
Answer: The pseudo skill turns a goal into a procedural retrieval proxy. It may locate related documents, but it is not verified and may not fit the subgoal. CSI rechecks evidence, constraints, and the next bounded action, linking retrieval to correct use without assuming imagined steps are executable.
Illustrative example: Example: A pseudo skill can find a web download procedure. Before executing, check whether the current page requires login instead of following a similar document title blindly.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
What is HSR capability round-robin trading off against global top-score selection?
Imagine Before Acting: Prospective Skill Identification for LLM Agents
Show answer and example
Answer: Global top scores can all come from one easily matched capability, missing other requirements. HSR ranks within capability and cycles through rows with deduplication to preserve coverage. Min–max normalization within candidate sets makes scores set-dependent, not calibrated success probabilities across tasks.
Illustrative example: Example: A task needs cleaning, plotting, and export. Round-robin gives each a candidate instead of using all five slots for cleaning.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Does CSI check every five reasoning turns or every five executed actions?
Imagine Before Acting: Prospective Skill Identification for LLM Agents
Show answer and example
Answer: It counts actually executed actions. Before the next action, recheck the current subgoal, evidence, and constraints; MATCH or PARTIAL_MATCH loads the real procedure first. Loading is not tool success, and invalid pseudo skills are not heuristically fabricated. Report loads, executions, and final passes separately.
Illustrative example: Example: Three reflections without tool execution do not advance the action counter or trigger the periodic check early.
Sections in the Chinese source: 核心公式, 本地复现, 数据协议、结果与边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why can multi-file skill packages serve as mid-training data for a causal LM?
SPT: Skills as Pre-Training Data for Agentic Language Models
Show answer and example
Answer: They contain reusable procedures and referenced materials. Predicting this text before post-training can build workflow priors. This is not a single execution trace or real tool use during training; downstream SFT or RL still must turn document patterns into behavior.
Illustrative example: Example: Instructions with a configuration example and helper script teach a reusable method, not the accidental full tool log of one task.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why is inserting referenced files near first use more complete than pretraining on skill instructions alone?
SPT: Skills as Pre-Training Data for Agentic Language Models
Show answer and example
Answer: Skill packages put argument rules or examples in companion files. Inlining at first reference exposes real dependencies at the right position in causal context rather than training on dangling references. Mixing with general text limits distribution shift. Reading skill documents is not validated execution.
Illustrative example: Example: 'Use schema.json for arguments' does not teach the field constraints if the schema is absent; inserting it near the reference supplies them.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
How does skill mid-training differ from retrieving skill documents only at deployment?
SPT: Skills as Pre-Training Data for Agentic Language Models
Show answer and example
Answer: Mid-training writes procedural patterns into weights, so the same document need not be retrieved each time. Runtime retrieval puts up-to-date skills explicitly in context but costs tokens. They can complement each other. Training on skill text does not prove tool execution; verify a real policy and environment.
Illustrative example: Example: A model may remember to verify before submitting, while a changed API argument still needs current runtime documentation.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Why retain general text and control its mixture with skill data in mid-training?
SPT: Skills as Pre-Training Data for Agentic Language Models
Show answer and example
Answer: Training data changes both what a model learns and the text distribution it sees. An explicit mixture coefficient α controls the share of procedural packages. Replacing all training with skill documents does not leave other capabilities unchanged by assumption. Local assembly and mixture tests cannot establish general capability retention or execution skill.
Illustrative example: Example: A batch includes instructions and general prose. Raising the skill ratio changes the training emphasis, which requires training evaluation, not a file-count check.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why does CoVeMem retrieve collaborative memory based on the current candidate set?
When Memory Takes Gradients: Collaborative Vector Memory for Agentic Recommender Systems
Show answer and example
Answer: The average collaborative candidate representation describes the local need. The system retrieves matching history and projects it into LLM-readable soft tokens. This focuses memory on the ranking task rather than a fixed text profile of all history. New candidates can change retrieval for the same user.
Illustrative example: Example: Outdoor-gear candidates may retrieve related purchases, while skin-care candidates retrieve a different portion of the same user's history.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why use semantic alignment and a masked listwise objective instead of simply making LightGCN vectors soft tokens?
When Memory Takes Gradients: Collaborative Vector Memory for Agentic Recommender Systems
Show answer and example
Answer: Matching projection dimension does not ensure use of collaborative geometry. Semantic alignment constrains the interface, and within-candidate ranking forces relevant memory to affect predictions. Candidate-driven retrieval changes history by option set. A frozen bank does not remove connector training or make explanations inherently faithful.
Illustrative example: Example: The same user needs different history for movies and books. Ranking supervision must teach soft tokens to affect the corresponding candidate scores.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
How does collaborative soft-token memory differ from repeatedly rewriting a textual profile?
When Memory Takes Gradients: Collaborative Vector Memory for Agentic Recommender Systems
Show answer and example
Answer: Soft tokens preserve collaborative geometry from a frozen LightGCN bank and use projection and alignment to interface with an LM. Text profiles are readable but require generative rewrites and can lose catalog structure. Vector interfaces need training and interpretation limits. No extra text-maintenance calls does not mean zero inference cost.
Illustrative example: Example: Ranking can read collaborative vectors without asking an LLM to rewrite preferences, but projection, retrieval, and language forward passes still consume compute.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
How does the mean candidate vector choose which collaborative memories to read from user history?
When Memory Takes Gradients: Collaborative Vector Memory for Agentic Recommender Systems
Show answer and example
Answer: Average the current candidates' vectors in the frozen bank, score historical items against that mean, select relevant items, and project them for the LLM. Changing candidates can change the read even when history is fixed. The local run verifies conditional retrieval, not training the paper's LightGCN, connector, or LoRA.
Illustrative example: Example: Switching the candidate set from cameras to hiking boots changes the mean and can surface photography versus outdoor interactions.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why not rely on the model to recall current progress from all chat history in a long task?
SKILL.state: Scalable Long-Horizon Agent Skills
Show answer and example
Answer: History grows and contains many failed attempts. Continuation needs clear completed work, unmet requirements, and key resources. SKILL.state maintains them as constrained execution state so new actions use current facts instead of reconstructing the whole past. The schema must be expressive enough.
Illustrative example: Example: After changing three files, one failing test remains. The next turn should see that explicit item instead of guessing from dozens of messages.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why isn't SKILL.state the full conversation with an extra state block?
SKILL.state: Scalable Long-Horizon Agent Skills
Show answer and example
Answer: The next step receives only skill instructions, current state, and latest observation. Older conversation is not replayed, so persistent information must be written explicitly. Recursive patches preserve untouched fields and allow deletion; validation precedes commit. Full history would bypass state sufficiency and the capacity constraint.
Illustrative example: Example: Save a previously confirmed file path in state to use it next turn. Secretly keeping the full chat would not test whether state suffices.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
How does a fixed-schema state update differ from a generic rolling summary?
SKILL.state: Scalable Long-Horizon Agent Skills
Show answer and example
Answer: Recursive patches preserve untouched fields and use null for explicit deletion. The runtime can check field names and types. Natural-language summaries are flexible but harder to constrain for overwrite and deletion. Valid structure does not guarantee factual contents or correct model updates.
Illustrative example: Example: A patch changing progress must preserve order_id. A prose rewrite may lose that ID without a clear field-level rejection.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
If action execution fails after valid state is committed, does the runtime undo state and external side effects?
SKILL.state: Scalable Long-Horizon Agent Skills
Show answer and example
Answer: No. The paper commits valid state before the action. A local executor error does not trigger blind retry or imply external rollback. The caller must process the failure as latest observation. Format-retry and character caps are local safeguards; counter events do not prove a real LLM can generate correct patches.
Illustrative example: Example: After recording a payment attempt, a network timeout does not justify resending it. Check the actual outcome to avoid double payment.
Sections in the Chinese source: 核心公式, 本地复现, 成本与复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why are several similar skills insufficient for an executable plan when the library grows?
CaSKG: Counterfactual-Causal Skill Graphs for Scalable Agent Skill Retrieval
Show answer and example
Answer: Skills can have order, input/output, and substitution relations. Similar wording does not make them compose. CaSKG retrieves skills together with reliable relations to avoid related but incompatible candidates. Calibration is needed beyond text similarity to claim dependency.
Illustrative example: Example: Both lookup and modification relate to orders, but modification may require confirming payment first. Omitting that relationship can cause a bad sequence.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why calibrate semantic and I/O similarity edges with remove, substitute, and reorder probes?
CaSKG: Counterfactual-Causal Skill Graphs for Scalable Agent Skill Retrieval
Show answer and example
Answer: Similarity helps recall but does not prove a dependency or order. Text counterfactuals alter local structure to see whether the relation still holds; smoothing retains more reliable edges. This is evidence under the probes, not a verified causal effect in a real environment.
Illustrative example: Example: Two skills mention uploading files, but removing authentication exposes a prerequisite. Shared vocabulary alone does not make them interchangeable.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
How does evidence from text counterfactual probes differ from real environmental interventions?
CaSKG: Counterfactual-Causal Skill Graphs for Scalable Agent Skill Retrieval
Show answer and example
Answer: Text probes edit skill descriptions or order to calibrate relations, but may reflect judgments about wording. Real execution must verify action consequences and state. A causal name does not turn textual edge reliability into unconfounded causal evidence; distinguish mechanisms from capability.
Illustrative example: Example: A model predicts deletion of a step causes failure, but another tool may fill the same role. Test execution rather than rely on the prediction.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
What do s, n, and the prior contribute to Bayesian smoothing?
CaSKG: Counterfactual-Causal Skill Graphs for Scalable Agent Skill Retrieval
Show answer and example
Answer: The posterior edge score is (α0+s)/(α0+β0+n). Successes add support, probe count controls shrinkage, and the prior avoids small-sample extremes. Publish only edges above threshold. One success is not probability one, and isolated local ToolRoute is not the full paper environment.
Illustrative example: Example: One probe success and a hundred successes are not equivalent once the prior and different evidence amounts are considered.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why does SkillForge teach skill selection rather than merely supplying a catalog?
SkillForge: Automated Skill Discovery and Refinement for Tool-Using Agents
Show answer and example
Answer: Procedural knowledge does not guarantee selection at the right time. Skills can be ignored, misused, or mismatched to current state. SkillForge learns invocation with actions and improves contents from execution, focusing on cooperation between knowledge and policy rather than document count.
Illustrative example: Example: A stored validate-before-import skill does not help an agent that always imports directly. Task feedback must affect selection.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why activate, revise, or deduplicate skill candidates instead of appending every success permanently?
SkillForge: Automated Skill Discovery and Refinement for Tool-Using Agents
Show answer and example
Answer: One success may depend on incidental conditions. Old skills can go stale or conflict. Multi-path induction proposes candidates, then policy choices and environmental feedback determine use and revisions. Appending expands the library without ensuring fit and can reinforce bad retrievals.
Illustrative example: Example: A download skill hard-codes an old button. If it fails in a new UI, revise or deactivate it instead of stacking another similar document.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
How does multi-path induction from success, failure, and contrasts differ from summarizing successes only?
SkillForge: Automated Skill Discovery and Refinement for Tool-Using Agents
Show answer and example
Answer: Success supplies usable steps, failure exposes boundaries, and contrast helps identify meaningful differences. Candidates need not repeat one success, but remain hypotheses until environment validation. Do not convert guesses in failure narratives into reliable rules or generalize from one successful case.
Illustrative example: Example: Both trajectories use the same query, but only the successful one verifies results. Propose verification as important and test it rather than immediately claim causality.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
What must the local check record for a_t=(environment action, skill choice)?
SkillForge: Automated Skill Discovery and Refinement for Tool-Using Agents
Show answer and example
Answer: Record the skill selected by the policy at action time and its execution outcome; a post-hoc label is not enough. Local structured plans verify invocation, posterior, and revision control flow without LLM teacher induction or RL. Reuse counts are not a learned policy or paper environment score.
Illustrative example: Example: Selecting a similar skill after an action to explain it is not actual use. Selection must influence action generation.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why can a multi-stage task leak irrelevant details into global decisions?
HyMem: Hierarchical Context Management for Long-Horizon Agents via Information Isolation
Show answer and example
Answer: Search, execution, and reasoning create many artifacts. Sending all of them to one context lets old logs or tentative assumptions distract planning. HyMem gives each stage the information it needs and uses progress records to continue, moving necessary evidence rather than sharing every token.
Illustrative example: Example: Hundreds of compiler lines may help the repair worker; global planning may need only the cause and affected module.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why can separating planning, execution, and isolated reasoning reduce context pollution?
HyMem: Hierarchical Context Management for Long-Horizon Agents via Information Isolation
Show answer and example
Answer: The layers need different detail: planning needs goal progress, execution needs current actions, and transient reasoning need not persist. Structured summaries retain necessary state across refreshes without crowding long-term facts with guesses. Isolation does not guarantee correctness; summaries must preserve constraints and provenance.
Illustrative example: Example: Pass verified interface changes and open issues from debugging to planning, not every tentative hypothesis as a lasting fact.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
What do structured progress summaries versus raw execution logs retain during handoff?
HyMem: Hierarchical Context Management for Long-Horizon Agents via Information Isolation
Show answer and example
Answer: Raw logs retain detail and many local attempts, leaving the next layer to identify what matters. Structured progress extracts completed work, current state, and open items, giving planning a stable starting point. Compression can omit constraints, so test whether the handoff supports continuation rather than counting text reduction.
Illustrative example: Example: Summarize installation logs as dependencies installed, tests not run due to missing credentials. 'Install succeeded' alone may be mistaken for completed verification.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Do deterministic local PlanBench results show that GAIA or BrowseComp-plus ran?
HyMem: Hierarchical Context Management for Long-Horizon Agents via Information Isolation
Show answer and example
Answer: No. Local tests cover layered context, refresh summaries, and mechanism counts without browsers, external tools, or the paper's large model. Cost units and saturated scores belong to the controlled protocol, not real long-horizon token costs or paper Pass@1.
Illustrative example: Example: Counting a summary as one fixture event does not show that a real web evidence summary preserves the same facts at the same cost.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why is admitting experience a risky step for a self-evolving skill library?
When Self-Evolution Backfires: Pre-Commit Gating against Skill Contamination in LLM Agents
Show answer and example
Answer: Candidate experience influences later actions and can be abstracted into new skills. One bad suggestion can therefore harm more than the current task. VaG limits this propagation so continual learning does not gradually corrupt long-term memory. Write volume does not measure progress.
Illustrative example: Example: A temporary check bypass gets generalized into a rule and reused across tasks. A short-term success becomes long-term contamination.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why can't deleting harmful skills after writing fully replace pre-admission validation?
When Self-Evolution Backfires: Pre-Commit Gating against Skill Contamination in LLM Agents
Show answer and example
Answer: A skill can influence new trajectories and descendant skills, spreading corruption before removal. Deleting its original entry does not undo derivatives. Precommit checks structure, behavioral harmlessness, and semantic consistency before choosing a compatible set. Admission and runtime rollback are distinct. Good individual skills may conflict together.
Illustrative example: Example: An incorrect retry rule has been absorbed into another skill. Removing the original does not repair its descendant; validate before writing to reduce inherited corruption.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
Why keep separate structural, behavioral harmlessness, and semantic consistency gates?
When Self-Evolution Backfires: Pre-Commit Gating against Skill Contamination in LLM Agents
Show answer and example
Answer: Structure checks parsability and references, behavior checks whether known executions regress, and semantics checks intended meaning. Valid formatting can hide bad actions, and one harmless run can miss unsafe preconditions. The gates supply complementary evidence but remain limited by case coverage.
Illustrative example: Example: A perfectly formatted skill reverses 'back up, then edit.' Parsing passes it, but semantic or behavioral validation can detect the reversal.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Why not combine all individually high-scoring skills in the Hot set?
When Self-Evolution Backfires: Pre-Commit Gating against Skill Contamination in LLM Agents
Show answer and example
Answer: Skills can conflict or duplicate, so set utility depends on shared context. VaG selects compatible combinations by marginal gain, not the sum of independent scores. Local tests cover gates and selection, not an expensive judge or original environment. Registering discovery does not prove a promotable real controller is integrated.
Illustrative example: Example: One skill requires caching first; another clears cache every step. Each can work alone, yet loading both requires a compatibility check.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why does GSE need a Skill Relation Graph for globally reusable skills?
Learning Globally Reusable Skills for Coding Agents
Show answer and example
Answer: Local experiences may overlap, complement, or conflict. The graph supports clustering and merges that avoid many near duplicates. Relationships still need evidence: semantic similarity does not make merging safe, especially when abstraction can erase environmental preconditions.
Illustrative example: Example: Both tasks run tests, but one first generates configuration and the other already has it. Preserve the difference when merging.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why run replay verification after clustering and merging similar local skills?
Learning Globally Reusable Skills for Coding Agents
Show answer and example
Answer: Similar wording can hide different preconditions, and merging can remove a branch critical to some tasks. Replay checks whether global reuse sacrifices old behavior, while the relation graph manages conflicts. Compact clusters and new successes do not independently establish safe merges or cross-distribution transfer.
Illustrative example: Example: Merge parsers for files with and without headers, then replay both cases so the unified flow does not keep only one assumption.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
How does global skill integration change the library differently from appending each task's experience independently?
Learning Globally Reusable Skills for Coding Agents
Show answer and example
Answer: Appending preserves local detail but accumulates similar, condition-specific, or conflicting skills. Integration uses relations to build reusable abstractions. It is not mere text deduplication: retain preconditions and validate old behavior. A smaller library or denser relations do not establish better execution.
Illustrative example: Example: Two export tasks save files, but one requires encryption and the other publication. Preserve those conditions rather than merge them into publish everything.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Do local relation-graph and regression-penalty tests reproduce industrial Agent F1?
Learning Globally Reusable Skills for Coding Agents
Show answer and example
Answer: No. The public mini-suite executes graph, selection, and regression operators without the paper's large model, private industrial environment, or expensive judge. Industrial F1 is full author-system evidence, not a consequence of smaller graphs or fixture scores.
Illustrative example: Example: Merging ten skills into five shows the merge happened. Without industrial test-generation tasks, it cannot imply precision or recall.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why account separately for memory-writing and memory-use costs in long-lived assistants?
MemoryCPT: An End-to-End Agent Memory Framework for Cost-Performance Trade-off
Show answer and example
Answer: History is written continually, while repeated queries trigger retrieval and summaries. Frequencies and cost drivers differ. MemoryCPT studies the end-to-end trade-off, making construction cheaper and reads question-specific. Shortening one summary does not establish system efficiency.
Illustrative example: Example: Hundreds of daily writes and five reads make different bottlenecks than five writes and hundreds of reads.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why does Quality per Cost require more than shortening a query summary?
MemoryCPT: An End-to-End Agent Memory Framework for Cost-Performance Trade-off
Show answer and example
Answer: Cost savings can harm answer quality, so the ratio may not improve. Construction, retrieval, and summarization each have inference costs. Offline chain distillation reduces construction, RRF and query-focused summaries manage reads, and cost-aware reward judges the pipeline. Compare the same quality definition rather than call fewer tokens success.
Illustrative example: Example: Reducing 500 words to twenty may omit a crucial exception and cause a wrong answer. Eighty useful words may offer a better quality-cost trade-off.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
Why optimize construction cost and per-query cost separately?
MemoryCPT: An End-to-End Agent Memory Framework for Cost-Performance Trade-off
Show answer and example
Answer: Construction processes incoming history, and reads recur with queries. They have different frequencies and useful information. MemoryCPT distills offline chains for construction and applies rank fusion and query-related summaries for reads. Sum actual write and query frequencies and check answer quality before claiming total savings.
Illustrative example: Example: Thousands of turns written but two queries can make construction dominate. Hundreds of reads from one history can compound small per-read savings.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Can text concatenation stand in for RRF retrieval and a LoRA summarizer?
MemoryCPT: An End-to-End Agent Memory Framework for Cost-Performance Trade-off
Show answer and example
Answer: No. RRF actually fuses rankings, the summarizer generates query-relevant context, and cost-aware GRPO needs real rewards and updates. Local tests retain core selection or state diagnostics without paper-scale training or benchmarks. Interface fields are not completed distillation or RL.
Illustrative example: Example: Concatenating two ranked lists performs neither reciprocal rank fusion nor learned summarization. Supplying the text to a model does not mean QAR ran.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why manage long-term memory, active context, and episodic history together?
Show answer and example
Answer: They jointly decide where information lives and what is visible. Separate optimization can misalign writing, restoring, and reading. VerMem selects atomic operations with one policy and verifies transitions locally and evidence globally. A shared policy does not make the state types interchangeable.
Illustrative example: Example: A fact in long-term memory needs retrieve or restore before answering. Merely existing in history does not make it visible.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why check memory actions with separate local and global verifiers?
Show answer and example
Answer: Local checks validate one transition contract but cannot judge consistency across a long trajectory. Global verification checks the relationship between the whole trace and final memory. Both complement task reward so legal individual steps cannot quietly accumulate into false state. Verifier pass rate is not task accuracy.
Illustrative example: Example: Deleting a field may be locally valid but remove the only evidence for a later answer. Global evidence consistency should catch that.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
Why do final task reward and memory-operation checks supervise different things?
Show answer and example
Answer: Final reward measures the overall result but cannot locate a retrieval, storage, or restore fault. Verification checks transitions and evidence, while operation cost controls resource use. Success can contain illegal or wasteful steps, and legal steps can fail to solve the task. Keep the signals distinct.
Illustrative example: Example: A lucky correct answer does not justify deleting key evidence. A legal retrieval need not find the answer.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Does nonzero local operation telemetry reproduce all seven operations and full RL?
Show answer and example
Answer: No. The README says the local run maintains three states and executes core retrieve, add, restore, and related paths. Counts prove those branches ran, not original multi-GPU RL or full environments. Claims must follow actual operations and budgets, not method names or counts.
Illustrative example: Example: A positive restore count means recovery was invoked, not that a learned policy picks the right time on real long tasks.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why do routing policy and memory-bank updates affect each other?
Show answer and example
Answer: Routing determines which memories are used; outcomes update route and memory utility. Content and graph changes then change route value. Optimizing one side alone can preserve the other's defects. CoEvo-Mem alternates updates and learns only from actual trajectories, not invented results for untried routes.
Illustrative example: Example: A route keeps selecting stale records. Changing the bank alters its payoff; after the update, routing must learn which paths work.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why alternate freezing the router and memory bank rather than updating both freely each round?
Show answer and example
Answer: Routing changes which memories are seen; bank changes alter router feedback. If both drift together, effects are hard to attribute. Freeze one while updating the other to limit nonstationarity, and use a lightweight residual to preserve the base LLM prior. This makes feedback easier to learn and audit without guaranteeing convergence or gains.
Illustrative example: Example: Freeze memory to compare routes, then freeze routing to revise low-value entries. Changing both at once makes a failure hard to locate.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
What are the roles of the frozen LLM's routing prior and the trainable residual router?
Show answer and example
Answer: The base LLM contributes task understanding as a routing prior. A residual changes selection using real interaction feedback without retraining the full model. The prior bounds updates, while the residual adapts to current memory. It learns from executed routes only and is not guaranteed to beat the prior.
Illustrative example: Example: A base route favors generic retrieval, but the residual learns from current tool tasks to favor an experience store. The language model's weights stay frozen.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Why include task axis and tool signature in a retrieval key instead of reusing by query text alone?
Show answer and example
Answer: Similar queries may need different routes for different tasks or tool versions. Axis and signature prevent reuse across incompatible contracts. The local run checks rewrite, residual, and alternating update flow. A public mini-suite and Evolve registry entry do not establish full learning or all paper benchmarks.
Illustrative example: Example: Two order lookup services return different schemas. Matching query words do not justify a memory route that uses obsolete fields.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why does one policy alternate solving the current task and curating a skill document?
Show answer and example
Answer: Solving produces experience; curation passes transferable material directly into the next task, making cross-task learning part of behavior. Related tasks progress from easy to hard, so documents must help later rather than simply explain present success. This is not independent episode training and not a mandate to keep all experiences.
Illustrative example: Example: After a simple file search, record location and verification methods for a harder modification task instead of copying the old answer.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why reward skill-document curation from later tasks rather than current task success?
Show answer and example
Answer: Current success mostly reflects solving, not whether the resulting skill helps later users or the same agent. Related tasks form a sequence, and discounted downstream returns supervise curation toward transferable experience. Apply the two phase advantages to their own generated tokens rather than broadcasting credit.
Illustrative example: Example: A lucky correct answer can still yield a reusable testing procedure. Its curation value is visible only if it helps later tasks.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
How does a connected curriculum transfer experience differently from training episodes independently?
Show answer and example
Answer: A skill document curated from one task becomes input to the next, so transferable experience can be used and evaluated. Independent episodes normally do not expose this link. Related tasks can overfit a curriculum; distinguish downstream document benefit from current solving and do not infer generalization from transfer counts.
Illustrative example: Example: A simple table cleanup produces checks for a constrained variant next. Random unrelated tasks may never use those checks.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Do local document-update and downstream-credit counts mean Qwen3 was trained with RL?
Show answer and example
Answer: No. Controlled PlanBench tests state evolution, skill transfer, and phase-specific credit without Qwen3 training or the paper's three environments. Writes show the action happened, not parameter learning. Perfect mini-suite scores are not comparable with paper Pass@k.
Illustrative example: Example: Deterministic rules can write 120 documents. Without real gradient updates, that is not the paper's shared-policy training.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why can't UniMem handle streaming tasks with fixed weights alone or by accumulating raw episodes indefinitely?
Show answer and example
Answer: Fixed weights cannot promptly absorb new situations. Raw episodes create growing retrieval and context costs. UniMem combines recent examples with stable recurring knowledge to adapt and reuse experience. Timeliness and stability matter, and frequent patterns are not necessarily correct.
Illustrative example: Example: Record a new service's first interface change as a specific event. Only after a rule continues to hold is it a candidate for a stable habit.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why first keep new tasks in an episodic buffer and consolidate only repeated reliable patterns?
Show answer and example
Answer: An isolated event may be noise or exceptional. Episodic storage preserves context; repeated reliable patterns are better candidates for stable parametric knowledge. Self-routing chooses how to use both. Repetition needs reliability checks so recurring mistakes are not consolidated as rules.
Illustrative example: Example: Record the first temporary outage as an event. Only repeatedly confirmed configuration constraints should become a general pattern.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
What is the trade-off between episodic retrieval and parametric memory for updates and use?
Show answer and example
Answer: Episodic entries are easy to append, audit, and delete, but reads consume retrieval and context. Parametric memory internalizes recurring patterns for direct use, but individual facts are harder to undo. The approaches are complementary; consolidation is not merely copying tables and can accumulate errors.
Illustrative example: Example: Keep a temporary meeting date as traceable episodic memory. A stable tool-use pattern may be worth consolidating and changes less often.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Does the local parametric route actually extend LLM weight blocks?
Show answer and example
Answer: No. Local parametric memory is a structured pattern table that tests thresholds, episodic-to-consolidated routing, and counts. It neither trains nor expands model weights. Consolidation counts and deterministic success do not establish LLM internalization or streaming capability.
Illustrative example: Example: Adding a rule after three occurrences is a state transition. If model weights did not change, it is not parametric learning.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why are high-level skills and AtomicOps different node types?
Show answer and example
Answer: High-level skills describe goals and reusable procedures. AtomicOps are executable actions linked through decomposition. Treating both as text snippets blurs abstract plans and immediately executable actions. Ground operations using current state and tool contracts rather than executing a high-level name.
Illustrative example: Example: Organize orders is high level; query, verify status, and write output are atomic operations that can become legal calls after decomposition.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why distinguish decomposition, temporal, and recovery edges in a skill graph?
Show answer and example
Answer: Decomposition maps a high-level goal to AtomicOps; temporal edges constrain ordering; recovery edges provide failure paths. A generic similarity edge would lose execution semantics. After retrieving a subgraph, ground it in current state. Finding a skill name is not action completion.
Illustrative example: Example: Upload decomposes into selecting and submitting a file. A failure can follow a recovery edge to refresh login; doing that as a universal prerequisite is unnecessary.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
What is the trade-off between retrieving a relevant skill subgraph and placing the whole graph in context?
Show answer and example
Answer: A subgraph limits interpretation and grounding to useful decomposition, order, and recovery relations. The full graph keeps more paths but costs more context and choices. A local subgraph can miss remote prerequisites, so check execution conditions; shorter input is not necessarily better task performance.
Illustrative example: Example: Retrieve the failed upload and nearby recovery nodes. If authentication is absent, the compact subgraph still cannot execute legally.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Does constructing a graph from controlled trajectories show an online LLM learned to extract skill relations?
Show answer and example
Answer: No. Local nodes and relations are supplied by controlled traces, testing hierarchy, subgraph retrieval, and reuse without online LLM extraction. AtomicOp reuse counts show real reuse within the fixture, not semantic discovery in open environments or extrapolated token savings.
Illustrative example: Example: Following a supplied recovery edge tests the graph executor. It does not show a model can infer that edge from an unseen failure log.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why does MemCon make whether to use memory a control action?
Memory as a Controlled Process: Learned Adaptive Memory Management for LLM Agents
Show answer and example
Answer: Retrieval, plan injection, query changes, and maintenance cost work. Some simple tasks are cheaper without memory. MemCon selects based on discrete progress, repetition, and memory size, then learns from terminal success and efficiency. Memory need not run on every turn.
Illustrative example: Example: With an obvious next tool, skip retrieval. After repeated failure and with a relevant successful plan, inject it or search deeper.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why must the memory controller count UCB visits per discrete state rather than use global action frequencies?
Memory as a Controlled Process: Learned Adaptive Memory Management for LLM Agents
Show answer and example
Answer: An operation useful early may not help later or under memory pressure. State-local values and counts let the controller learn those trade-offs separately. It explores unvisited actions first, then updates from terminal success and efficiency. No extra LLM call applies to selection; retrieval and execution still have costs.
Illustrative example: Example: Deep retrieval may help at the start and delay completion near the end. Count attempts separately instead of sharing one global success rate.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
What is the trade-off between tabular UCB and asking an LLM to choose a memory policy every round?
Memory as a Controlled Process: Learned Adaptive Memory Management for LLM Agents
Show answer and example
Answer: Tabular control needs no extra model call and has interpretable states and actions, but limited discrete features cannot express arbitrary semantic contexts. LLM control is flexible but costs calls. State-local UCB does not guarantee convergence as the environment and memory change.
Illustrative example: Example: A repetition flag can trigger deeper retrieval immediately. Semantically different tasks with the same discrete state may still look identical to the table.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Can MemCon's Q update use sample-mean UCB or TD bootstrapping?
Memory as a Controlled Process: Learned Adaptive Memory Management for LLM Agents
Show answer and example
Answer: No. The local implementation follows v3 state-local counts, discounts terminal success and efficiency by distance, and updates repeated state-action pairs in reverse order. It does not bootstrap future Q. Unvisited actions go first with initial Q tie-breaking. Differences from mutable upstream main counts are documented.
Illustrative example: Example: An action seen twice in one episode receives two discounted updates in reverse order, not one reward averaged by visits.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
What repeated work does Memento-Skills avoid across similar tasks?
Show answer and example
Answer: A run records useful steps, errors, and conditions. Raw logs still need interpretation next time. Memento-Skills makes experience searchable and updatable for reuse. Usefulness depends on applicability and actual execution; storage and version counts do not measure capability.
Illustrative example: Example: After discovering a billing date-format issue, reuse a skill with format validation instead of rereading the entire failure log.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why are versioned skills more reusable than appending raw execution logs to context?
Show answer and example
Answer: A log describes one run. Structured skills extract applicability and steps for later retrieval. Versioned merge tracks corrections instead of keeping contradictory old copies. Abstraction must preserve provenance and failure conditions; shorter wording does not make it a reliable general procedure.
Illustrative example: Example: A deployment log contains temporary directories and retry noise. The skill retains dependency checks and rollback conditions, and a later version fixes obsolete arguments.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
How does versioned Merge differ from appending a new skill every time?
Show answer and example
Answer: Merge integrates feedback into relevant existing skills and records changes rather than accumulating near duplicates. Appending is simpler but can retain contradictory versions. Merge must preserve applicability and check regressions; one topical or successful example does not justify a global replacement.
Illustrative example: Example: Update an export skill for a pagination limit. If it applies to one service only, keep that condition rather than requiring pagination everywhere.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
What does low local joint success with nonzero skill telemetry show?
Show answer and example
Answer: The mechanism ran and many tasks still failed. Creation or reuse counts cannot be cherry-picked as improvement. Local tests cover state updates and fair budgets without the original large model, real web, or full benchmark. Keep negative outcomes with process evidence.
Illustrative example: Example: Ten skill retrievals show invocation happened. If the task failed, they do not establish correct content or execution benefit.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why does U-Mem treat missing knowledge as an active acquisition problem?
Show answer and example
Answer: Similar memories can omit a necessary fact or procedure. Repeated retrieval can leave the same gap. U-Mem learns to acquire information from self, tools, or experts as needed and considers reuse afterward. New knowledge needs provenance and feedback; an expert label does not guarantee truth.
Illustrative example: Example: Memory contains only an obsolete API call. Find new documentation for missing arguments instead of returning the old fragment repeatedly.
Sections in the Chinese source: 背景与主要改动, 核心公式与算法. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why escalate acquisition from self or teacher to tool research to an expert instead of always asking the strongest expert?
Show answer and example
Answer: Costs differ. Try cheaper potentially adequate paths first and reserve costly help for persistent uncertainty. Thompson sampling combines historical utility and uncertainty, and memory is verified before writing. The cascade orders value and cost decisions, not a claim that cheap sources are always correct.
Illustrative example: Example: Check memory for common configuration, then docs, then an expert only if ambiguity remains.
Sections in the Chinese source: 背景与主要改动, 核心公式与算法. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
How does semantic similarity plus Thompson sampling differ from ranking memory by similarity alone?
Show answer and example
Answer: Similarity favors related content. Beta posterior samples explore uncertain memories that may be useful, then outcomes update the posterior. This is not random insertion of irrelevant material. The uncertainty–relevance balance depends on real feedback rather than confidence alone.
Illustrative example: Example: Two records are equally related, one well tested and one new. Sampling can occasionally test the newer one instead of always selecting the highest old score.
Sections in the Chinese source: 背景与主要改动, 核心公式与算法. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
What limits follow from deterministic local experts and knowledge sources?
Show answer and example
Answer: They omit real search failures, hallucination, paid models, and token cost. They verify escalation, validation, writes, and proxy cost accounting only. Receiving preset correct knowledge after low confidence does not reproduce HotpotQA, AIME, or real savings.
Illustrative example: Example: A fixture expert always returns a supplied fact. That tests escalation control flow, not real expert request success or cost.
Sections in the Chinese source: 核心公式与算法, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why do pre-action clarification and post-action correction complement each other?
Learning Personalized Agents from Human Feedback
Show answer and example
Answer: Clarify unknown or uncertain preferences before acting to reduce guesses. Feedback after execution corrects the action and stale memory, handling drift. A confident old belief is not grounds to reject correction when preferences change by context or time.
Illustrative example: Example: Someone formerly liked spicy food but wants mild today. Ask first if uncertain; if an order is already wrong, update based on the explicit correction.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why allow users to correct preferences after action even when prior memory is confident?
Learning Personalized Agents from Human Feedback
Show answer and example
Answer: Confidence describes current memory, not whether preferences changed with time or context. Retrieval and clarification before action address uncertainty; afterward correction replaces stale content. Accepting feedback only at low confidence can permanently lock in learned mistakes or drifted preferences.
Illustrative example: Example: A user previously preferred early flights but changed routines. Update the preference after rejection rather than booking early flights on old confidence.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
How does explicit preference memory differ from providing a hidden user persona as ground truth?
Learning Personalized Agents from Human Feedback
Show answer and example
Answer: Memory comes from actual user feedback and has observable provenance. Hidden persona or gold action belongs only to evaluation. Giving it early removes the personalization problem. PAHF learns preferences and drift through interactions rather than reading a test specification.
Illustrative example: Example: Store that a user said they avoid coffee on workdays. Do not feed the identical statement from a hidden fixture before interaction.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Why keep current context and remembered preference together in PAHF policy input?
Learning Personalized Agents from Human Feedback
Show answer and example
Answer: Actions depend on instructions, observations, explicit memory, and pre-action feedback. A preference is not a context-free global command. Tie new feedback to its context to avoid converting one situational change into a permanent rule. The local implementation tests memory and feedback contracts, not the original robot or shopping simulator.
Illustrative example: Example: Selecting sugar-free drinks for guests today does not necessarily change personal taste. Keep the scene to understand correction scope.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why turn one-off experiences into callable operational knowledge in MemSkill?
Show answer and example
Answer: Episodic memory records what happened, while later tasks may need repeatable steps, preconditions, and recovery. MemSkill extracts skills and lets execution select relevant memories. Over-abstraction can lose conditions, and repeated success is not universal applicability. Check transfer through actual execution.
Illustrative example: Example: A spreadsheet repair includes long dialogue. Future work needs check column names before date conversion and the conditions where that rule applies.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why are controller memory selection and designer skill compilation different jobs?
Show answer and example
Answer: Selection decides which experiences the current task reads. Compilation turns recurring successes into reusable procedures on a longer timescale. Feedback also drives versions. One retrieved success does not establish that every detail should be consolidated; distinguish reusable steps from incidental conditions.
Illustrative example: Example: Retrieve a prior fix for today's error and compile a skill only after confirming a repeated pattern. Do not hard-code a temporary account from one log.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
Why is repeated success stronger evidence for consolidation than a single successful trace?
Show answer and example
Answer: One success may depend on chance or hidden help. Repetition supports a pattern across instances and makes it a better skill candidate. It does not prove causal necessity; inspect prerequisites, failures, and version changes. Frequency does not replace validation.
Illustrative example: Example: Three successes clear cache first because those tasks may all need it. Record the condition rather than mandate clearing cache everywhere.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
What is the evidence boundary between local skill-version updates and full designer learning?
Show answer and example
Answer: The local run verifies selection, compilation-style transitions, versions, and budgets without the paper's LLM, RL, or real environment. Version increments show the path ran, not reliable skill extraction from natural-language logs. Perfect controlled scores are not paper cross-task ability.
Illustrative example: Example: Rules can convert recurring steps to a template for a pipeline test. Without a learned designer, do not claim open-task procedure discovery.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why make use of accumulated skills a learning objective in SAGE?
Show answer and example
Answer: Stored skills need timely, correct selection and can harm when mismatched. SAGE connects experience-derived skills to retrieval and uses later outcomes to govern their lifecycle. It studies durable use of experience, not library size or successful trace count.
Illustrative example: Example: A migration skill is irrelevant to looking up one row. Knowing when not to invoke it is useful skill selection.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why revise or retire skills from successful trajectories after later failures?
Show answer and example
Answer: Success establishes utility under past conditions, not new ones. Returns train selection and reveal obsolete content. Revision and eviction stop accumulation of errors. An append-only library can keep retrieving relevant-looking stale skills and reinforce incorrect behavior.
Illustrative example: Example: A download skill worked before a site redesign. Update or disable it rather than rank it first based on old success.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
How does learned retrieval qφ differ from fixed semantic nearest neighbors?
Show answer and example
Answer: Semantic nearest neighbors use description similarity. Learned retrieval adapts to which skills improve execution returns. Outcomes are confounded by environment and task difficulty, so success after invocation is not independent causal contribution. Inspect updates with bank state and visible evidence.
Illustrative example: Example: Two skills sound like file organization. A more reliable route can get a higher learned score even if it shares fewer words.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Can SAGE and sage-planner share implementation conclusions because they have the same name?
Show answer and example
Answer: No. SAGE concerns an RL-driven skill library; sage-planner concerns symbolic action gates and suffix edits. The local SAGE run tests skill state and budgets, without paper-scale models or benchmarks. Shared names do not fill evidence gaps.
Illustrative example: Example: A skill-library revision invokes no symbolic gate. Gate tests from the other method cannot verify this one.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why does LegoMem focus on recurring workflows with multiple roles and steps?
Show answer and example
Answer: Office workflows share portions but change goals and roles. Reorganizable procedures let new tasks reuse the right steps rather than copy one complete run. Units must retain dependencies and context; pieces that look composable can still lack inputs.
Illustrative example: Example: Weekly reports and project briefs both need collection and source verification, but different approvers. Reuse collection and replan handoff.
Sections in the Chinese source: 背景与主要改动, 核心公式与算法. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why separate orchestration and execution memory for recombination on new tasks?
Show answer and example
Answer: Decomposition and delegation capture high-level dependencies, while action templates ground calls. One full trace binds them to particular people and environments. Layers can reuse structure while swapping execution units. Admit verified units only and recheck interfaces and prerequisites when combining them.
Illustrative example: Example: Collect, verify, and summarize stays the same while data comes from a database in one task and a file in another.
Sections in the Chinese source: 背景与主要改动, 核心公式与算法. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
What generalization trade-off separates procedural recombination from whole-trace retrieval?
Show answer and example
Answer: Whole traces preserve complete context but may be tied to one task. Procedural units recombine for new needs but can lose cross-unit prerequisites. Legal dependencies and validation are needed; individual success does not imply arbitrary compositions work.
Illustrative example: Example: Reading a spreadsheet and sending email may both work alone. Verify recipients and data permissions before combining.
Sections in the Chinese source: 背景与主要改动, 核心公式与算法. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Does local reused_plans verify real multi-agent Office delegation?
Show answer and example
Answer: No. The local run extracts action/domain units from structured verifiable plans and reuses high-level and fine-grained steps. It does not execute Office apps, LLM delegation, or complete recovery. Reuse counts are neither OfficeBench success nor real tool cost.
Illustrative example: Example: A rule reuses a subplan 100 times without showing a model can delegate between real document and email apps.
Sections in the Chinese source: 核心公式与算法, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why do tool descriptions need bounded dynamic memory?
Show answer and example
Answer: MCP schemas and instructions consume context, while static truncation can remove tools in use. MemTool protects current workflow requirements and manages other descriptions dynamically. Preserve executable interfaces rather than maximizing removals.
Illustrative example: Example: An order lookup followed by refund still needs the refund tool even if it was not called recently.
Sections in the Chinese source: 背景与主要改动, 核心公式与算法. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why protect workflow-required tools before considering recency or historic success?
Show answer and example
Answer: Retention scores reflect past usage and may undervalue an uncalled but required future tool. Protect dependencies first, then evict lower-scoring unprotected entries. If required tools exceed capacity, silent truncation does not preserve a valid workflow.
Illustrative example: Example: Upload is required at the end of archiving even if not recently used. Do not remove it solely for low recency.
Sections in the Chinese source: 背景与主要改动, 核心公式与算法. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
How do autonomous, workflow, and hybrid tool-description policies make decisions?
Show answer and example
Answer: Autonomous lets the agent decide retention; workflow uses current process requirements; hybrid protects those requirements and dynamically manages remaining tools. Freedom and structural constraints differ. Removal rate is insufficient if eviction prevents completion.
Illustrative example: Example: An agent may discard rare payments before one is needed. Workflow information protects payment while hybrid manages other entries.
Sections in the Chinese source: 背景与主要改动, 核心公式与算法. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
How should recency and historical success scores evict unprotected tools?
Show answer and example
Answer: Restrict candidates to those outside the protected workflow set. Keep scores λ times recency plus (1−λ) times success; evict the lowest. The weight trades off recency and history without redefining protection. Local deterministic descriptions and eviction counts do not establish live tool completion.
Illustrative example: Example: One evictable tool was just used but often fails; another is older but reliable. λ controls the choice, and required tools do not enter this ranking.
Sections in the Chinese source: 核心公式与算法, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why does MemGPT compare long documents and conversations to limited-memory management?
Show answer and example
Answer: One context window is finite while user material can be much larger. MemGPT lets agents schedule information across visible working memory and external storage to continue long tasks. Archive capacity does not imply current knowledge; finding, paging, and storing information affect answers and cost.
Illustrative example: Example: To answer about a six-month-old contract, locate and page in the relevant record. Having the file on disk is not enough.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why actively manage page-in and page-out when the external archive is large?
Show answer and example
Answer: Archive capacity is not visible context. Relevant material must enter the working window to affect an answer. Paging links storage to the current task, and heartbeats or interrupts schedule further evidence gathering and user interaction. A virtual-memory interface does not let a model see unlimited history at once.
Illustrative example: Example: An old address remains in the archive. Retrieve and page it in before answering a shipping question.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
How does a heartbeat differ from a normal user-facing response in control flow?
Show answer and example
Answer: Heartbeat or interrupt continues internal memory and tool work rather than treating each operation as a final response. This is a scheduling interface, not a guarantee of correct invocation. Unconditional loops can waste budget, so use it only for relevant pending work.
Illustrative example: Example: After paging old content out, continue internal retrieval and answer once relevant evidence is loaded instead of returning a partial status as the answer.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Does deterministic key-based page-in establish semantic archive retrieval?
Show answer and example
Answer: No. Local tests cover hierarchical state, paging, and interrupt counts, using deterministic keys instead of embeddings or LLM function calls. Proxy cost is not token count or latency. Paging works, but real autonomous evidence retrieval from long documents is unverified.
Illustrative example: Example: Getting an entry by order123 is easier than understanding and retrieving the user's vaguely mentioned last order.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why does Voyager use code as an action instead of only a natural-language plan?
Show answer and example
Answer: Code invokes environment APIs over extended behavior and can be iteratively repaired from errors and observations. Successful programs enter the library for reuse. Natural-language plans still need executable mapping. Runnable code can also be wrong and needs environmental validation.
Illustrative example: Example: Compile collecting wood into movement, search, and harvesting loops, then inspect inventory. Saying 'chop a tree' does not perform those actions.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why admit only programs verified by the environment to Voyager's skill library?
Show answer and example
Answer: Plausible code can fail because materials are missing, APIs are wrong, or goals are unmet. Environment feedback exposes these failures. Index confirmed successes for reuse. The automatic curriculum picks new goals and the library retains verified behavior; code generation alone cannot substitute.
Illustrative example: Example: A program for crafting an iron pickaxe is not a successful skill if inventory lacks iron. Only actual completion supports future reuse.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
How does automatic curriculum differ from a fixed checklist for accumulating skills?
Show answer and example
Answer: The curriculum chooses novel goals from current state and skills. A fixed list is controlled but cannot adapt to capability. Self-selected goals can favor easy novelty, so validate outcomes and progress rather than treat task count or exploration distance as general capability.
Illustrative example: Example: After acquiring stone tools, mining explores more than repeated wood gathering, but completion still depends on inventory and milestones.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Is the local structured-plan skill library equivalent to Mineflayer JavaScript programs?
Show answer and example
Answer: No. Curriculum, skills, verification, and cross-episode reuse are retained with structured tool plans. The run omits Minecraft, GPT-4, and embedding retrieval. Controlled retry counts do not represent real program debugging or paper item and distance gains.
Illustrative example: Example: Reusing a plan template does not show handling Mineflayer's asynchronous movement errors or achieving its technology-tree gains in a new world.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
How does reflection differ from recording a single observation?
Show answer and example
Answer: Observations are concrete events. Reflection draws higher-level inferences across important memories for retrieval and planning. Inferences can be wrong and are not primary evidence. Keep observations traceable and plans grounded in current state.
Illustrative example: Example: Several helpful acts may suggest someone is cooperative. That is an abstraction, not a new observed event, and should retain support.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why shouldn't an important old event automatically replace more query-relevant memory?
Show answer and example
Answer: Importance captures long-term significance, relevance measures current fit, and recency models decay. Reflection abstracts several important events, but actions still need current state. Using one dimension alone can repeat major events or focus only on recent chatter.
Illustrative example: Example: Moving home was important, but last night's restaurant confirmation better answers today's dinner-location question.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
What questions do reflection and planning answer in everyday behavior simulation?
Show answer and example
Answer: Reflection forms higher-level interpretations from experiences, such as relationship or habit inferences. Planning schedules what to do next using goals, memory, and time. Inferences are not events, and plans are not executed results. Separation makes both evidence and actual behavior traceable.
Illustrative example: Example: Inferring that a neighbor likes gardening is reflection. Deciding to invite them to buy seeds this afternoon is planning.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Do local reflection triggers include a social evaluation of 25 LLM personas?
Show answer and example
Answer: No. Controlled EvoMem tests three-score retrieval, cumulative-importance triggers, and planning dependencies without a Smallville map, real personas, or human credibility judgments. Reflection counts and proxy costs show mechanism execution, not believable relationships or coordination.
Illustrative example: Example: A threshold producing one rule-based reflection does not show models spreading invitations or arranging a party.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why not rewrite every memory used after a team failure?
Remembering Is Not Enough: Refining Memories and Learning When to Use Them in Multi-Agent Systems
Show answer and example
Answer: Another role, a tool or an out-of-scope scenario may have caused the failure. DiscernMem compares replay with just the suspect memory against no-memory replay on the same task, seed and configuration. It then asks whether the rule body is defective or a useful rule was used out of scope. A negative effect alone does not prove a defective body.
Illustrative example: Example: Repair the source before running tests may help with code bugs. If the test environment is broken, more source edits can harm. Add an avoid scope rather than delete a useful source-repair rule.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why compare a proposed repair to both its parent memory and a no-memory baseline?
Remembering Is Not Enough: Refining Memories and Learning When to Use Them in Multi-Agent Systems
Show answer and example
Answer: The parent may already be harmful. Merely beating it can still underperform injecting nothing. For each task in the fixed trigger and history sets, the proposal must match the better reference minus tolerance, without adding outright failures. This protects tested behavior, not every unseen task.
Illustrative example: Example: Parent 0.2, no memory 0.8, proposal 0.7. The proposal beats its parent by 0.5 but misses the 0.79 threshold with default tolerance 0.01; reject it.
Sections in the Chinese source: 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
How does testing only on the triggering failure differ from DiscernMem's cross-task validation?
Remembering Is Not Enough: Refining Memories and Learning When to Use Them in Multi-Agent Systems
Show answer and example
Answer: A local fix can harm past capabilities. DiscernMem fixes a set of triggers, previous positive-effect tasks and related tasks, then applies thresholds per task, not to the mean. Related tasks must not regress; they need not improve. Origin tasks are excluded from history validation so the original example cannot repeatedly validate its own memory.
Illustrative example: Example: Trigger improves 0.4→0.9 and an old task drops 0.8→0.5. Reject even though the mean improves.
Sections in the Chinese source: 核心公式, 数据协议与实现边界. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Why can't a new memory body inherit the parent's success evidence?
Remembering Is Not Enough: Refining Memories and Learning When to Use Them in Multi-Agent Systems
Show answer and example
Answer: Effects are tied to the body actually used. The new body has not shown the same reliability. Keep identity, owner and compliant correction history, but clear previous effect evidence and mark the new version provisional. This versioning component is not evidence of LLM repair or multi-agent ability.
Illustrative example: Example: v2 worked on ten tasks. If v3 adds a stopping condition, keep v2 records but start v3's effects empty; do not say v3 passed the ten tasks.
Sections in the Chinese source: 核心公式, 数据协议与实现边界, 本地结果与负控. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Basics
Why doesn't EMMA turn every failure into a new skill?
EMMA: Structured Episodic Memory for Multi-Agent Workflow Synthesis
Show answer and example
Answer: Ownership depends on the error. Use task-local plan guidance for one execution slip, agent prompts for general habits, skills for missing procedures and controller changes for routing. Experience at the wrong scope can fail to trigger or interfere elsewhere.
Illustrative example: Example: Checking units can be reusable. One misclick does not require a permanent unit-check skill or a new agent.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Core mechanism
Why require one edited entry and retain at least 60% of old prompt lines?
EMMA: Structured Episodic Memory for Multi-Agent Workflow Synthesis
Show answer and example
Answer: Single-entry and ownership scope bound location; retention, length and pool capacity bound magnitude. Only agents involved in the failed attempt may change. New entries must actually be used in the next plan. Structural validity is not better task performance.
Illustrative example: Example: Keeping two of five lines and replacing the role is rejected. Keeping three and adding a local check reaches 60%, but still needs an external rerun.
Sections in the Chinese source: 核心公式, 本地结果与负控. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Method comparison
Why treat context overflow differently from missing capability?
EMMA: Structured Episodic Memory for Multi-Agent Workflow Synthesis
Show answer and example
Answer: Overflow can mean a step is too broad. Split incomplete steps and resume without discarding finished work. A new specialist needs evidence of missing capability or repeated overflow; repeated overflow calls for changing the decomposition, not simply changing prompts/skills.
Illustrative example: Example: If steps one and two already produced a table and step three is too large, keep the table and subdivide step three among existing agents.
Sections in the Chinese source: 背景与主要改动, 核心公式, 代码映射. The example illustrates the mechanism.
Agents / Memory and skills: retrieval, reuse, and invalidation
Implementation details
Do passing local guards prove no memory leakage and a stronger agent?
EMMA: Structured Episodic Memory for Multi-Agent Workflow Synthesis
Show answer and example
Answer: No. The code checks ownership, capacity, retention, rotation, lifecycle and concatenation. Independent external services judge semantic deduplication, real specialization and leakage; the component cannot prove those judgments correct. No evaluated actor, LLM reflection or real task traces.
Illustrative example: Example: A service may incorrectly mark an answer-bearing proposal safe. A Boolean interface cannot detect that; local rejection counts are not AppWorld success rates.
Sections in the Chinese source: 数据协议与实现边界, 本地结果与负控, 高成本完整实验. The example illustrates the mechanism.
Topic guide and reading order
Start with this question¶
When history exceeds the context window, what should be saved, when should it be retrieved, and how can stale knowledge be kept from misleading a new task?
Takeaway¶
Memory is state with write, retrieve, update, and eviction policies. MemGPT moves information between storage tiers so a limited window can access archives on demand. Voyager stores successful programs as retrievable skills. Facts, temporary inferences, and executable skills have different reuse conditions; facts can expire and a program may require a specific tool version. Start from the future decision and retain evidence for it. EMMA distinguishes one execution mistake, a persistent habit, a missing method, and misrouting before changing a plan, prompt, skill, or controller. Responsibility for repair matters as much as storage tier.
Example¶
For a data project across sessions, keep confirmed unit conventions in resident memory, the current question and intermediate statistics in working memory, and complete queries and sources in the archive. When a table changes, verify schema before reusing query skills. Invalidate old units if the user changes them. Compressing everything to “prefers brevity” cannot recover calculation rules.
Common pitfall¶
Readable summaries may still lose essential details. A retrieval hit may not apply. Evaluate task results, storage and call budgets, propagation of errors, and cross-user isolation. Local paging, skill lookup, or state fixtures do not establish real long-term memory or runs in original environments such as Minecraft.
Reading order¶
Read MemGPT for moving information between context and archives, Voyager for executable skills versus facts, and Generative Agents for connecting retrieval, reflection, and planning without treating simulated social behavior as production evidence.
Check your understanding¶
A skill once passed tests and has the highest retrieval score, but its tool interface just changed. Should the agent run it immediately?
Show suggested answer
First check interface version, input assumptions, and permissions, then run a cheap validation. Similarity does not establish present applicability. Track scope, feedback, and invalidation. If compatibility cannot be verified, use current evidence rather than trusting a historical pass.