PrisMemRead the paper
Microsoft
University of Science and Technology of China
University of California, San Diego

AGENT MEMORY / SELF-EVOLUTION

PrisMem
Capability-Driven Self-Evolution of Agent Memory

Yaoqi Chen1,2,*Yuru Feng2,3,*Qianxi Zhang2Baotong Lu2Jianan Lu2Zhirui Wang2Shusen Xu2Zewen Jin2Zengzhong Li2Cheng Li2Qi Chen2
1 University of Science and Technology of China2 Microsoft3 University of California, San Diego

* Equal contribution

+10.54pp

BEAM-1M

Over strongest baseline
+7.83pp

LongMemEval-M

Over strongest baseline
1M+

Tokens of history

Generalization to longer contexts

01 / THE INSIGHT

80.5% of revisions with no overall gain still improve at least one capability.

Existing self-evolving memory methods revise a memory program using one overall score. But memory is multidimensional, and that score blurs what each revision actually achieved.

Four panels showing hidden capability gains, uneven capability changes, and conceptual exploration boundaries
Figure 1. Why capability-driven evolution matters. Analysis of M⋆ and EvolveMem evolution traces on BEAM.

We derive five representative capabilities from a broad review of agent memory benchmarks and memory systems. Then we annotate every question with the one it primarily requires, plus up to two secondary ones. These labels only organize feedback during evolution and are never given to the memory program at test time.

F

Factual retrieval

Preserve and retrieve explicit facts, values, and other localized details.

T

Temporal tracking

Order events, determine recency, track states and knowledge updates.

P

Preference extraction

Recover and apply user preferences, instructions and constraints.

M

Multi-session synthesis

Aggregate and synthesize evidence across multiple sessions or events.

A

Adversarial

Abstain when memory lacks supporting evidence, or cautiously resolve contradictory or misleading evidence.

02 / THE METHOD

Explore separately.
Improve together.

PrisMem evolves an executable memory program in three stages: build a base, grow capability specialists, then integrate them.

PrisMem method overview with cold start, dependency-aware selection, history-guided diagnosis, specialist refinement and trace-guided integration
Figure 2. Overview of PrisMem: cold start, capability refinement, and trace-guided integration.

ZOOM IN · STAGE II

Every round makes two choices before any code changes.

Which capability to refine, and which of its failures to learn from.

CHOICE 1 · DEPENDENCY-AWARE SELECTION

Which capability to refine?

urgency = own error + strongest pressure on another capability1 + times already picked

F Factual
picked 1× → ÷2
T Temporal
not picked yet
P Preference
picked 1× → ÷2
M Synthesis
picked 2× → ÷3
A Adversarial
not picked yet

A capability is chosen because it is weak itself, or because it holds another capability back. Each past pick lowers its priority, so plateaued capabilities step aside: here T wins although M has the larger raw urgency (dashed).

CHOICE 2 · HISTORY-GUIDED DIAGNOSIS

Which failures to learn from?

priority = how well earlier programs answered ittimes it, or a similar case, was already picked

ALL TRAINING CASES OF THE TARGET CAPABILITY✕ already answered well (score > 0.8)REMAINING FAILURES, RANKED BY PRIORITY5 cases → diagnosis

A case that used to be solved and now fails shows exactly what a recent revision broke. Discounting repeats keeps the five cases diverse.

Schematic diagrams with illustrative values. They show the idea behind the two selection rules (Eqs. 1–7 in the paper).

ZOOM IN · STAGE III

Every integration rests on evidence and a plan.

Paired differential cases show where programs behave differently; the integration plan decides what to carry over.

EVIDENCE · PAIRED DIFFERENTIAL CASES

Where do two programs really differ?

ONE CASETWO PROGRAMSTWO OUTCOMES ? program A program B 1.0 0.0 paired caseΔ = 1.0
F FactualP131vsP170.5+ bring in
T TemporalP70.4vsP171◆ protect
P PreferenceP151vsP170+ bring in
M SynthesisP101vsP170+ bring in
A AdversarialP70.25vsP171◆ protect

Specialist wins → bring in. Base P17 wins → protect.

PLAN · LINEAGE-ORDERED INTEGRATION

What to take, and what to guard?

SPECIALISTS · CLOSEST LINEAGE FIRST BaseTA62.5FactualspecialistFsynthesis rulesPreferencespecialistPpreference ruleSynthesisspecialistMtopic metadataUnified65.8

While contrasting cases serve as diagnostic indicators targeting specific program components, the plan leverages these insights to localize code modules and formulate a step-by-step integration strategy.

03 / LIVE DEMO

Watch memory evolve.

One real 20-round run on BEAM, replayed step by step: which program was revised, what failed, and what changed.

04 / THE EXPERIMENTAL RESULTS

Built on shorter histories.
Tested at a million tokens.

Static memorySelf-evolving baselinesPrisMem

3 runs · Bars show means · whiskers show ±1 standard deviation.

BEAM-1M

Qwen3.8-27B

Capability scores (%) ↑

Factual retrieval

BEAM-1M: Factual retrieval050100Mem0: 54.74 ± 3.06 %Mem0A-MEM: 56.21 ± 1.83 %A-MEMHippoRAG2: 65.24 ± 1.26 %HippoRAG2SimpleMem: 48.55 ± 3.33 %SimpleMemLightMem: 46.66 ± 0.82 %LightMemM⋆: 61.29 ± 5.14 %M⋆EvolveMem: 41.80 ± 4.77 %EvolveMemPrisMem: 74.17 ± 4.87 %PrisMem
PrisMem: 74.17 ± 4.87 %

Temporal tracking

BEAM-1M: Temporal tracking050100Mem0: 46.51 ± 0.79 %Mem0A-MEM: 46.22 ± 0.62 %A-MEMHippoRAG2: 47.06 ± 1.85 %HippoRAG2SimpleMem: 36.82 ± 0.47 %SimpleMemLightMem: 33.40 ± 0.65 %LightMemM⋆: 48.98 ± 5.87 %M⋆EvolveMem: 39.74 ± 3.15 %EvolveMemPrisMem: 57.26 ± 2.15 %PrisMem
PrisMem: 57.26 ± 2.15 %

Preference extraction

BEAM-1M: Preference extraction050100Mem0: 60.48 ± 2.39 %Mem0A-MEM: 65.39 ± 0.52 %A-MEMHippoRAG2: 66.43 ± 1.57 %HippoRAG2SimpleMem: 48.85 ± 1.19 %SimpleMemLightMem: 36.64 ± 0.63 %LightMemM⋆: 71.91 ± 3.40 %M⋆EvolveMem: 52.21 ± 1.53 %EvolveMemPrisMem: 75.58 ± 3.91 %PrisMem
PrisMem: 75.58 ± 3.91 %

Multi-session synthesis

BEAM-1M: Multi-session synthesis050100Mem0: 38.02 ± 0.63 %Mem0A-MEM: 53.87 ± 0.86 %A-MEMHippoRAG2: 44.83 ± 0.60 %HippoRAG2SimpleMem: 21.87 ± 2.00 %SimpleMemLightMem: 16.70 ± 0.89 %LightMemM⋆: 42.19 ± 4.88 %M⋆EvolveMem: 21.67 ± 3.07 %EvolveMemPrisMem: 54.12 ± 3.37 %PrisMem
PrisMem: 54.12 ± 3.37 %

Adversarial

BEAM-1M: Adversarial050100Mem0: 49.11 ± 1.24 %Mem0A-MEM: 41.13 ± 0.51 %A-MEMHippoRAG2: 44.82 ± 2.28 %HippoRAG2SimpleMem: 50.68 ± 0.40 %SimpleMemLightMem: 55.45 ± 0.94 %LightMemM⋆: 46.02 ± 7.52 %M⋆EvolveMem: 45.67 ± 3.50 %EvolveMemPrisMem: 64.32 ± 6.51 %PrisMem
PrisMem: 64.32 ± 6.51 %

Overall

% · higher is better

BEAM-1M: Overall050100Mem0: 48.95 ± 0.61 %Mem048.95A-MEM: 51.56 ± 0.62 %A-MEM51.56HippoRAG2: 51.86 ± 0.87 %HippoRAG251.86SimpleMem: 40.18 ± 0.76 %SimpleMem40.18LightMem: 36.44 ± 0.38 %LightMem36.44M⋆: 52.85 ± 2.49 %M⋆52.85EvolveMem: 40.01 ± 1.46 %EvolveMem40.01PrisMem: 63.39 ± 1.02 %PrisMem63.39
PrisMem: 63.39 ± 1.02 %

Average token usage per question (K) ↓

lower is better

BEAM-1M: Average token usage0250500Mem0: 190.28 ± 0.20 K tokens / questionMem0190.28A-MEM: 428.95 ± 3.58 K tokens / questionA-MEM428.95HippoRAG2: 207.70 ± 0.19 K tokens / questionHippoRAG2207.70SimpleMem: 95.72 ± 0.24 K tokens / questionSimpleMem95.72LightMem: 86.20 ± 0.05 K tokens / questionLightMem86.20M⋆: 89.47 ± 5.11 K tokens / questionM⋆89.47EvolveMem: 98.40 ± 4.67 K tokens / questionEvolveMem98.40PrisMem: 100.59 ± 5.02 K tokens / questionPrisMem100.59
PrisMem: 100.59 ± 5.02 K tokens / question

PrisMem leads all five capability metrics on BEAM-1M and improves Overall by 11.53 pp over the strongest static baseline (10.54 pp over the strongest self-evolving baseline), while using fewer tokens per question than Mem0, A-MEM, and HippoRAG2.

GPT-5.5

Overall

% · higher is better

BEAM-1M with GPT-5.5: Overall050100Mem0: 57.77 ± 0.17 %Mem057.77A-MEM: 60.92 ± 0.41 %A-MEM60.92HippoRAG2: 57.73 ± 0.50 %HippoRAG257.73SimpleMem: 52.36 ± 0.55 %SimpleMem52.36LightMem: 46.68 ± 0.05 %LightMem46.68M⋆: 60.75 ± 2.53 %M⋆60.75EvolveMem: 46.77 ± 1.56 %EvolveMem46.77PrisMem: 67.09 ± 1.79 %PrisMem67.09
PrisMem: 67.09 ± 1.79 %

Average token usage per question (K) ↓

lower is better

BEAM-1M with GPT-5.5: Average token usage0250500Mem0: 180.21 ± 0.12 K tokens / questionMem0180.21A-MEM: 352.11 ± 0.25 K tokens / questionA-MEM352.11HippoRAG2: 193.52 ± 0.18 K tokens / questionHippoRAG2193.52SimpleMem: 121.39 ± 0.69 K tokens / questionSimpleMem121.39LightMem: 94.05 ± 0.19 K tokens / questionLightMem94.05M⋆: 97.47 ± 4.75 K tokens / questionM⋆97.47EvolveMem: 94.39 ± 3.08 K tokens / questionEvolveMem94.39PrisMem: 99.36 ± 3.62 K tokens / questionPrisMem99.36
PrisMem: 99.36 ± 3.62 K tokens / question

Why it works

Integration keeps the peaks

Capability scores on BEAM · dashed: best ever reached · solid: final program

Figure 3(b): radar comparison of M star, EvolveMem and PrisMem across factual, temporal, preference, multi-session and adversarial capabilities. Dashed lines show historical capability-wise peaks and solid lines the final selected program.

PrisMem reaches further than holistic evolution on every capability, and its final program closely matches its peaks.

Every design choice matters

Overall score lost when a component is removed (pp) · BEAM-1M · full PrisMem: 63.39

Capability-driven evolution−10.15
Random case selection−5.26
Trace-guided integration−3.16
Round-robin target selection−2.55

Removing capability-driven evolution yields the largest drop by blurring potential optimization directions when focusing solely on overall performance. Meanwhile, substituting with random case selection, omitting trace-guided integration, and simplifying to round-robin target selection degrade results by removing informative failure feedback, program fusion, and priority targeting.

Transfer Experiments

To a different model

Evolve withQwen3.8-27Bfrozen programRun withGPT-5.5

60657067.25± 1.35Evolved withQwen3.8-27BTRANSFERRED67.09± 1.79Tested withGPT-5.5TARGET MODELbest baseline60.92

To a different dataset

Evolve onBEAM-100Kfrozen programRun onLongMemEval-M

60708076.50± 1.67Evolved onBEAMTRANSFERRED75.50± 1.80Tested onLongMemEvalTARGET DATASETbest baseline67.67

These results show that the evolved memory programs maintain strong performance even when transferred to different models and datasets without additional program optimization, demonstrating the robustness and generalizability of the capability-driven evolution approach.

Capability Router Experiments

Route to a specialist, or integrate?

Capability-best programs come from the same PrisMem evolution run

ROUTING

question ? FTPMAone capability-best program per question
  • Question-only router predicts the capability from the question alone.
  • Oracle-label router is given the benchmark’s own question type.

Integration beats both routers

Overall score (%) ↑ · Qwen3.8-27B on BEAM-1M · mean ± std · Table 12 · y-axis starts at 50

50607057.74± 1.21Question-onlyrouter62.27± 1.14Oracle-labelrouter63.39± 1.02PrisMemintegration

In contrast, trace-guided integration combines complementary mechanisms within a shared program and reconciles their conditions of use, resulting in stronger overall performance. These results support the value of integrating useful capability-specific revisions into a shared memory program.

Final Evolved Memory Program

Evolution starts from the same seed program (left). On the right is the final program PrisMem evolved from it.

seed_program.pySEED PROGRAM28 lines
from dataclasses import dataclass, field MemoryExtractionInstruction = "Extract the key information from the text into several memory units."QueryPlanningInstruction = "Given the following question, generate a query to retrieve relevant memory."AnswerInstruction = "Based on the retrieved memory and the original question, provide a short answer without explanation." @dataclassclass MemoryUnit:    memory_text: str = field(        metadata={"description": "One piece of information worth remembering from the text"}    ) @dataclassclass Query:    query_text: str = field(        metadata={"description": "A query for retrieving information relevant to the question"}    ) class Memory:    def __init__(self, backend):        self.backend = backend        self.memories: list[str] = []     def index(self, units: list[MemoryUnit], raw_text: str) -> None:        self.memories.extend(unit.memory_text for unit in units)     def retrieve(self, query: Query) -> str:        return "\n\n".join(self.memories)[:OUT_CHAR_BUDGET]
evolved_on_beam.pyEVOLVED ON BEAM279 lines
import reimport numpy as npfrom dataclasses import dataclass, field MemoryExtractionInstruction = (    "Extract distinct atomic facts, decisions, preferences, "    "instructions, and temporal events from the text. "    "Resolve pronouns and references to full names. Preserve "    "exact values, names, dates, times, and lists verbatim. "    "If the text contains a user preference or standing "    "instruction, capture it explicitly as its own memory "    "unit. For cross-cutting preferences or standing "    "instructions that apply broadly regardless of the "    "specific topic or project (e.g. 'always format code "    "with syntax highlighting', 'prefer minimal "    "dependencies', 'always compare multiple solution "    "methods'), set standing_preference to True. For "    "preferences tied to a specific project, feature, or "    "domain (e.g. 'prefers Bootstrap for this website'), set "    "standing_preference to False. Capture any "    "contradictions or updates to previously stated facts. "    "For each fact, assign a concise topic identifier "    "(entity+thread in lowercase hyphenated form, e.g. "    "'weather-app-autocomplete', "    "'greg-research-collaboration', "    "'triangle-classification-progress') that groups all "    "related facts about the same ongoing thread, project, "    "or person across sessions. Set session_date to the "    "current conversation session date in YYYY-MM-DD format "    "(the date the user discussed the topic in chat, NOT any "    "project or schedule date in the content).") QueryPlanningInstruction = (    "Given the question, decompose it into one or more "    "retrieval sub-queries. For single-topic questions, "    "provide exactly one sub-query. For multi-aspect, "    "synthesis, or multi-part questions, provide one "    "sub-query per distinct topic or aspect so that all "    "relevant evidence scattered across sessions is "    "retrieved independently. Each sub-query should be "    "concise and contain the key entities, specific time "    "references, and the particular aspect being asked "    "about. For temporal questions include relevant date or "    "event words. For preference or instruction questions "    "include the domain and the type of constraint. For "    "existence or experience questions (e.g. 'Have I ever "    "done X', 'Have I completed X', 'Did I do X before', "    "'Have I used X'), include an additional sub-query "    "targeting negation or absence (e.g. 'never X', 'not "    "done X before', 'no prior experience with X', 'has not "    "attempted X') so that explicit denial or inexperience "    "statements are retrieved with equal prominence "    "alongside affirmative evidence.") AnswerInstruction = (    "Based on the retrieved memory context and the original "    "question, provide a concise and accurate answer. Each "    "entry is prefixed with [YYYY-MM-DD] showing the session "    "date when the user discussed that topic. For questions "    "about the order or sequence in which the user raised "    "topics, use these session-date prefixes to determine "    "chronological order. Distinguish statement time (the "    "[YYYY-MM-DD] prefix) from event time (dates within the "    "entry text, e.g. project schedules). For synthesis or "    "summary questions, group entries by topic and present a "    "unified chronological narrative of how the user's "    "project or understanding progressed, describing how "    "earlier sessions set the stage for later developments. "    "For count or total questions about progress across "    "sessions, sum values reported in separate distinct "    "events (e.g. 'completed 10' in one session then "    "'completed 15' in a later session = 25 total); use the "    "latest value only when entries track a single running "    "total. However, if two values appear to be "    "contradictory statements about the same quantity in the "    "same session or context, do NOT sum them-surface the "    "contradiction instead. If the context contains "    "contradictory information, explicitly surface the "    "contradiction and note the conflicting details. If the "    "context does not contain sufficient information to "    "answer, state that clearly rather than guessing. If any "    "retrieved entry states a user preference or standing "    "instruction (e.g., 'always include...', 'I prefer...', "    "'make sure to...'), you MUST apply that constraint to "    "the structure and content of your answer-not merely "    "acknowledge it. If a [Standing Preferences] section "    "appears in the retrieved context, apply every "    "preference listed there. CRITICAL for existence or "    "experience questions (e.g. 'Have I ever X', 'Did I do "    "X', 'Have I completed X before'): if the retrieved "    "context contains BOTH affirmative evidence that the "    "user did, completed, or used X AND explicit statements "    "that the user never did X, has not done X, or has no "    "prior X, your answer MUST lead with the contradiction. "    "Present both the affirmative evidence and the negation "    "statement explicitly, briefly quote or paraphrase each, "    "and ask the user to clarify which is correct. Do NOT "    "resolve the contradiction by picking one side, "    "dismissing one as outdated, or explaining away the "    "other.") @dataclassclass MemoryUnit:    memory_text: str = field(        metadata={"description": "One atomic piece of information worth remembering: a fact, event, preference, decision, or instruction. Include specific names, values, and dates."}    )    session_date: str = field(        default="",        metadata={"description": "The conversation session date in YYYY-MM-DD format. This is the date of the current chat session, not any project or schedule date mentioned in the content."}    )    topic: str = field(        default="",        metadata={"description": "A concise topic identifier in lowercase-hyphenated form (entity+thread) grouping related facts across sessions. Examples: 'weather-app-autocomplete', 'triangle-classification-progress', 'portfolio-website-sprint-1'. Use 'general' if no clear thread."}    )    standing_preference: bool = field(        default=False,        metadata={"description": "True ONLY for cross-cutting user preferences or standing instructions that apply broadly regardless of topic (e.g. 'always use tree diagrams for probability', 'prefer minimal dependencies'). False for topic-specific facts or one-off requests."}    ) @dataclassclass Query:    query_texts: list[str] = field(        metadata={"description": "A list of retrieval sub-queries. Each sub-query targets one distinct topic or aspect. For single-topic questions use one entry. For multi-aspect or synthesis questions, decompose into one sub-query per distinct topic so that all relevant evidence is retrieved. Each should contain key entities, time references, and the specific aspect being asked about."}    ) class Memory:    def __init__(self, backend):        self.backend = backend        self.memories: list[str] = []        self.embeddings: list[np.ndarray] = []        self.session_dates: list[str] = []        self.topics: list[str] = []        self.standing_prefs: list[str] = []        self.topic_to_indices: dict[str, list[int]] = {}     _STOP = frozenset(        "the a an is are was were in on at to for of and or but if how what when where who which did do does have has had i my me you your we our they their it its this that with from by as be been being am will would can could should may might shall not no yes any all each every some there here so than too very just also only own same out up down over under again further then once your you my me i we they he she it its his her their our your mine yours his hers ours theirs".split()    )     @staticmethod    def _parse_session_date(raw_text: str) -> str:        header = raw_text[:500]        m = re.search(r'(\d{4})-(\d{2})-(\d{2})', header)        if m:            return f"{m.group(1)}-{m.group(2)}-{m.group(3)}"        m = re.search(r'(\d{1,2})/(\d{1,2})/(\d{4})', header)        if m:            return f"{m.group(3)}-{int(m.group(1)):02d}-{int(m.group(2)):02d}"        return ""     @staticmethod    def _content_tokens(text: str) -> set[str]:        return {t for t in re.findall(r"\b\w+\b", text.lower()) if t not in Memory._STOP and len(t) > 1}     @staticmethod    def _normalize_topic(topic: str) -> str:        return re.sub(r'[^a-z0-9]+', '-', topic.lower()).strip('-') or "general"     def _topic_tokens(self, topic: str) -> set[str]:        normalized = self._normalize_topic(topic)        parts = set(normalized.split('-'))        parts.add(normalized)        return {t for t in parts if len(t) > 2}     def index(self, units: list[MemoryUnit], raw_text: str) -> None:        if not units:            return        parsed_date = self._parse_session_date(raw_text)        texts = [u.memory_text for u in units]        embs = self.backend.embed(texts)        for i, u in enumerate(units):            sd = getattr(u, 'session_date', '') or parsed_date            topic = getattr(u, 'topic', '') or ''            sp = getattr(u, 'standing_preference', False)            self.memories.append(texts[i])            self.embeddings.append(embs[i])            self.session_dates.append(sd)            self.topics.append(topic)            norm_topic = self._normalize_topic(topic)            if norm_topic not in self.topic_to_indices:                self.topic_to_indices[norm_topic] = []            self.topic_to_indices[norm_topic].append(i)            if sp and texts[i] not in self.standing_prefs:                self.standing_prefs.append(texts[i])     def retrieve(self, query: Query) -> str:        if not self.memories:            return ""        sub_queries = query.query_texts        if not sub_queries:            return ""         # Build standing preferences block        standing_prefs_block = ""        if self.standing_prefs:            prefs_lines = [f"- {p}" for p in self.standing_prefs]            standing_prefs_block = "[Standing Preferences]\n" + "\n".join(prefs_lines)            if len(standing_prefs_block) > 400:                standing_prefs_block = standing_prefs_block[:400]        standing_overhead = (len(standing_prefs_block) + 4) if standing_prefs_block else 0        main_budget = OUT_CHAR_BUDGET - standing_overhead        if main_budget < 800:            main_budget = OUT_CHAR_BUDGET            standing_overhead = 0            standing_prefs_block = ""         n = len(sub_queries)        per_query_budget = main_budget // n        all_embs = np.stack(self.embeddings)        seen_texts: set[str] = set()        selected: list[tuple[float, str, str]] = []  # (score, session_date, text)         for sq in sub_queries:            query_emb = self.backend.embed([sq])[0]            cos_scores = all_embs @ query_emb            q_tokens = self._content_tokens(sq)            kw_scores = np.zeros(len(self.memories), dtype=np.float64)            if q_tokens:                for i, txt in enumerate(self.memories):                    t_tokens = self._content_tokens(txt)                    kw_scores[i] = len(q_tokens & t_tokens) / len(q_tokens)             # Topic boost            topic_boost = np.zeros(len(self.memories), dtype=np.float64)            if q_tokens:                for topic, indices in self.topic_to_indices.items():                    t_toks = self._topic_tokens(topic)                    if not t_toks:                        continue                    overlap = q_tokens & t_toks                    if len(overlap) >= 2:                        for idx in indices:                            topic_boost[idx] = 0.05                    elif len(overlap) == 1:                        for tok in overlap:                            if len(tok) > 4:                                for idx in indices:                                    topic_boost[idx] = 0.05                                break             scores = 0.7 * cos_scores + 0.3 * kw_scores + topic_boost            order = np.argsort(-scores)            used = 0            for idx in order:                idx = int(idx)                txt = self.memories[idx]                if txt in seen_texts:                    continue                sd = self.session_dates[idx] if idx < len(self.session_dates) else ""                prefix_len = len(sd) + 3 if sd else 0                cost = len(txt) + prefix_len + 2                if used + cost > per_query_budget:                    continue                selected.append((float(scores[idx]), sd, txt))                seen_texts.add(txt)                used += cost         if not selected:            return standing_prefs_block if standing_prefs_block else ""         # Keep relevance order; format with date prefix for temporal context        parts: list[str] = []        total = 0        for score, sd, txt in selected:            prefix = f"[{sd}] " if sd else ""            formatted = prefix + txt            sep = "\n\n" if parts else ""            if total + len(sep) + len(formatted) > main_budget:                break            parts.append(formatted)            total += len(sep) + len(formatted)         result = "\n\n".join(parts)        if standing_prefs_block:            result += "\n\n" + standing_prefs_block        return result[:OUT_CHAR_BUDGET]

05 / CITE

BibTeX

@misc{chen2026prismem,
  title = {Capability-Driven Self-Evolution of Agent Memory},
  author = {Chen, Yaoqi and Feng, Yuru and Zhang, Qianxi and Lu, Baotong and Lu, Jianan and Wang, Zhirui and Xu, Shusen and Jin, Zewen and Li, Zengzhong and Li, Cheng and Chen, Qi},
  year = {2026},
  eprint = {2610.06361},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2610.06361}
}