acceptodds
Under review as a conference paper at ICLR 2027

Beyond Memory Construction: Rethinking Memory Access for LLM-based Conversational Agents

Abstract

Memory is a core component of conversational agents, enabling coherent and context-aware behavior over long interactions. Recent approaches commonly rely on LLM-based memory construction, where raw interactions are rewritten into structured memory units and later retrieved via a RAG pipeline. While effective in controlled settings, we show that this paradigm breaks down in long-horizon, high-entropy conversations: memory construction becomes increasingly lossy and unstable as context length and information complexity grow, and incurs prohibitive cost due to repeated LLM invocation. To address these limitations, we propose Threader, a memory system that shifts the focus from memory construction to efficient, structure-aware access over raw interactions. Instead of rewriting interactions, Threader preserves them as first-class memory, organizes them into topic-coherent segments via lightweight incremental segmentation, and enables accurate retrieval through multi-view representation. At query time, it performs multi-signal retrieval that combines segment-level access with localized evidence matching, ensuring both completeness and coherence. Extensive experiments demonstrate that Threader consistently improves answer accuracy and evidence recall, while significantly reducing the memory construction overhead.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
LLM Agent Memory, Long-Term Conversational Memory, Conversational Agents

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_7WS8OpenReview ↗
Rating
2
Confidence
1(−2)
Informativeness
1
Presentation
2
Soundness
2
Read review
Paper summary

This paper studies long-term memory for LLM conversational agents. The authors show that LLM-based memory construction loses evidence and costs a lot when conversations get long and mixed. They propose Threader, which keeps raw dialogue, splits it into topic segments with a small BERT model, and retrieves segments with multi-view embeddings, BM25 and reranking. Experiments on LongMemEval and PersonaMem show better QA accuracy.

Critical strengths
  1. The motivation study is clear. The session concatenation experiment and the case studies show well how Mem0 and MemU lose evidence.

  2. Threader get the best overall accuracy on both LongMemEval and PersonaMem, and the gain holds with GPT and Qwen backbones.

  3. The paper gives many useful details in the appendix, such as the judge prompt, the response prompts and the segmenter training settings.

Critical weaknesses
  1. The novelty is limited. The core idea, splitting memory into topic segments, was already studied in SeCom. Authors basically turn SeCom’s prompt-based segmentation into a trained model, and the later recall, rerank and answer steps are incremental.

  2. As a method that improve QA by better chunking, the paper do not report detailed retrieval results. LongMemEval provide standard retrieval metrics like Recall and NDCG, but authors only report their self-defined Full-R and Mean-R, which is not reasonable.

  3. The released code can not reproduce the reported results. The key input, the segmented data, is not provided. Also the segmenter and its training code, and the baseline scripts are missing.

  4. The paper says Threader is slower than Self-RAG because of the extra segmentation step, but the timing code don’t include segmentation at all. Authors should explain this gap between the code and the paper.

Questions for authors
  1. Could the authors analyze the main differences between Threader and SeCom, besides replacing prompt-based segmentation with a trained model?

  2. Could the authors report standard retrieval metrics, such as Recall@k and NDCG@k, following its official protocol?

  3. Could the authors release the segmented data, the segmenter weights and its training code, and the scripts for running baselines?

  4. The authors should explain whether the 18.33s construction time includes the segmentation step. Could the authors report the segmentation time separately?

6 comments
AuthorsOpenReview ↗

Response to W1 & Q1

Thank you for your thoughtful comments! We address your comments point by point below.

W1/Q1: Differences from SeCom and additional comparisons

W1: The novelty is limited. The core idea, splitting memory into topic segments, was already studied in SeCom. Authors basically turn SeCom’s prompt-based segmentation into a trained model, and the later recall, rerank and answer steps are incremental.

Q1: Could the authors analyze the main differences between Threader and SeCom, besides replacing prompt-based segmentation with a trained model?

Threader and SeCom Both retrieve topic-organized dialogue. The key differences are:

  • Segmentation and scalability: SeCom relies on LLM-prompted segmentation, whose quality can be sensitive to the choice of LLM; Threader makes incremental boundary decisions with a lightweight segmenter, supporting long, evolving real-world histories without segmentation-related LLM calls.
  • Memory representation: SeCom uses compression-based denoising for retrieval; Threader retains raw evidence and constructs user-only, assistant-only, and full-interaction views to expose role-specific signals.
  • Evidence retrieval: SeCom scores segment-level memory units; Threader refines relevance using role-weighted message scores, then combines dense, lexical, and reranking signals to retrieve coherent segments, yielding more effective yet lightweight retrieval.

We additionally tested SeCom on LongMemEval and PersonaMem. On LongMemEval, accuracy under comparable retrieved-context token budgets is:

MethodGPT-5-nano accuracy (%)GPT-5-mini accuracy (%)Qwen3.5-plus accuracy (%)
SeCom75.0080.8055.60
Threader80.6090.6087.00

Threader outperforms SeCom across all three backbones, with gains of 5.60 and 9.80 percentage points on GPT-5-nano and GPT-5-mini, respectively. The advantage is especially pronounced on Qwen3.5-plus, reaching 31.40 percentage points (87.00% vs. 55.60%).

On PersonaMem, SeCom's prompt-based segmenter could not process the long sessions in our tested configuration, while Threader's incremental segmenter succeeded, highlighting its practical value for long conversational histories.

Regarding cost, SeCom construction takes 127.28 s per 100K input tokens and incurs $0.07 in segmentation-related LLM charges; Threader incurs no such LLM charges. Retrieval latency is 8.13 s (SeCom) versus 8.66 s (Threader). Threader thus delivers higher accuracy with comparable retrieval latency and no segmentation-related LLM costs.

AuthorsOpenReview ↗

Response to W2 & Q2

W2/Q2: Official LongMemEval metrics and retrieval results

W2: As a method that improve QA by better chunking, the paper do not report detailed retrieval results. LongMemEval provide standard retrieval metrics like Recall and NDCG, but authors only report their self-defined Full-R and Mean-R, which is not reasonable.

Q2: Could the authors report standard retrieval metrics, such as Recall@k and NDCG@k, following its official protocol?

Our Full-Recall@k uses the same definition as LongMemEval’s official recall_all@k. We use the name Full-Recall to distinguish it from Mean-Recall, an additional metric we report. Specifically, Full-Recall@k measures the fraction of queries for which all gold evidence is retrieved within the top-k results, whereas Mean-Recall@k averages the fraction of gold evidence retrieved per query.

We additionally report retrieval results following LongMemEval’s official retrieval evaluation protocol, we report Recall@k and NDCG@k and compare Threader with SeCom:

MethodRecall@5 (%)Recall@10 (%)Recall@12 (%)
SeCom60.0075.1177.87
Threader82.5591.2893.40
MethodNDCG@5NDCG@10NDCG@12
SeCom0.61680.66230.6704
Threader0.81580.83690.8412

Threader consistently outperforms SeCom across all tested k values, providing more complete evidence coverage and better ranking quality.

AuthorsOpenReview ↗

Response to W3&Q3 AND W4&Q4

W3/Q3: Released data and code for reproducibility

W3: The released code can not reproduce the reported results. The key input, the segmented data, is not provided. Also the segmenter and its training code, and the baseline scripts are missing.

Q3: Could the authors release the segmented data, the segmenter weights and its training code, and the scripts for running baselines?

We apologize for the incomplete initial release. The segmented data were initially omitted because their size exceeded GitHub’s file-size limits. We have now released the segmented data, segmenter weights, and training code on Anonymous Hugging Face. The provided code and input data enable reproduction of Threader's reported results. For baselines, we use scripts from the respective methods' official GitHub repositories. We are currently constructing an integrated evaluation environment incorporating multiple baselines, and will release this integrated evaluation framework upon publication.

W4/Q4: Construction time breakdown and segmentation overhead

W4: The paper says Threader is slower than Self-RAG because of the extra segmentation step, but the timing code don’t include segmentation at all. Authors should explain this gap between the code and the paper.

Q4: The authors should explain whether the 18.33s construction time includes the segmentation step. Could the authors report the segmentation time separately?

The 18.33 s per 100K input tokens reported in Table 4 is measured end-to-end and includes 6.07 s for segmentation. The released indexing script starts from pre-segmented data, so its timer does not cover segmentation.

Excluding segmentation, Threader's construction time is 12.26 s, slightly below Self-RAG's 13.18 s. Threader also achieves lower query-time latency (8.66 s vs. 93.52 s) and higher LongMemEval accuracy with GPT-5-mini (90.60% vs. 76.60%).

Reviewer_6hYROpenReview ↗
Rating
3
Confidence
4
Informativeness
2
Presentation
3
Soundness
3(+1)
Read review
Paper summary

This paper proposes Threader, a conversational memory system that retrieves evidence from raw interactions using incremental topic segmentation, multi-view representations, and hybrid retrieval. Experiments demonstrate improved accuracy and lower memory construction costs on LongMemEval and PersonaMem.

Critical strengths

The paper addresses a practical problem with a sensible evidence-preserving design. Evaluation across two benchmarks and multiple response models, together with component ablations, provides encouraging evidence of its usefulness.

Critical weaknesses

Major Concern 1: The implementation differs from the paper. The provided code uses reciprocal-rank fusion instead of Eq.(6)’s normalized-score fusion, adds role weights absent from Eq.(5), and restricts reranking to the top 20 candidates. These differences can affect rankings; the authors should clarify which implementation produced the reported results.

Major Concern 2: Training and evaluation are not clearly separated. The segmenter uses 30 LongMemEval histories for training and another 50 instances for calibration, yet results cover all 500 questions. The authors should clarify the splits and report results excluding training and calibration instances to avoid answer leakage concerns.

Major Concern 3: Segmentation robustness is unclear. The paper does not adequately explain how inputs exceeding BERT’s context window are handled or analyze how truncation and boundary errors affect subsequent segmentation.

Minor concern: Figure 2 could more clearly show how message-level scores are aggregated into segment-level scores, making the retrieval pipeline easier to follow.

Questions for authors

My main concerns revolve the weaknesses stated above. I am willing to improve my score if the correct implementation supports the reported findings and my concerns are satisfactorily resolved.

4 comments
AuthorsOpenReview ↗

Response to Major Concern 1 & 2

Many thanks for your constructive feedback! We address your comments point by point below.

Major Concern 1: Aligning the formulation with the implementation

Major Concern 1: The implementation differs from the paper. The provided code uses reciprocal-rank fusion instead of Eq.(6)’s normalized-score fusion, adds role weights absent from Eq.(5), and restricts reranking to the top 20 candidates. These differences can affect rankings; the authors should clarify which implementation produced the reported results.

We apologize for the lack of detail in the main text and thank the reviewer for identifying these inconsistencies. The released code is the correct implementation of Threader’s retrieval pipeline. These discrepancies arose from our overly condensed description in the main text. We have corrected the formulation and clarified the following details in the revised manuscript:

  1. Rank-based fusion. Dense and BM25 rankings are combined using weighted reciprocal-rank fusion (RRF), si(h)=1/ri(e)+β/ri(b)s_i^{(h)}=1/r_i^{(e)}+\beta/r_i^{(b)} (β=0.65\beta=0.65). Min–max normalization is applied only before the final fusion with cross-encoder scores.
  2. Role-weighted message refinement. Stage II extends Stage I's role-aware weighting rationale to individual messages, using separate weights: 0.7 for user and 0.3 for assistant similarities. These weights are applied before selecting and averaging the top-K2K_2 message scores (K2=2K_2=2).
  3. Reranking budget. Candidate truncation before reranking is optional and controlled by K3K_3. Setting K3K_3 sufficiently large reranks all candidates. The reported results use K3=20K_3=20, retaining the top 20 candidates after dense–BM25 fusion for reranking and final selection.

Major Concern 2: Training, calibration, and held-out evaluation

Major Concern 2: Training and evaluation are not clearly separated. The segmenter uses 30 LongMemEval histories for training and another 50 instances for calibration, yet results cover all 500 questions. The authors should clarify the splits and report results excluding training and calibration instances to avoid answer leakage concerns.

The 30 abstention instances used for segmentation supervision and the 50 calibration instances are disjoint. Segmentation training uses only boundary labels, while retrieval calibration uses evidence recall; neither uses gold answers or downstream QA accuracy.

To address the reviewer’s concern, we additionally report a held-out evaluation excluding all 80 training/calibration instances. With GPT-5-mini as the response backbone, Threader achieves 90.71% accuracy on the remaining 420 instances, compared with 90.00% on the 80 training/calibration instances. These results show that accuracy is maintained after excluding all instances used for training or calibration.

As shown in Table 2, the same segmenter and retrieval configuration also achieve 69.95% accuracy on PersonaMem with GPT-5-mini, without any additional training or calibration. This further supports the cross-dataset generalization of the learned segmenter and calibrated retrieval configuration.

AuthorsOpenReview ↗

Response to Major Concern 3 & Minor Concern

Major Concern 3: Long-input handling and incremental segmentation robustness

Major Concern 3: Segmentation robustness is unclear. The paper does not adequately explain how inputs exceeding BERT’s context window are handled or analyze how truncation and boundary errors affect subsequent segmentation.

We concatenate the current predicted segment buffer with the incoming turn and left-truncate inputs exceeding BERT’s context limit, retaining the most recent tokens. Only the segmenter’s input is truncated; the original dialogue remains intact in memory.

The segmenter uses a threshold τ\tau on its predicted boundary probability to decide whether to start a new segment. Higher thresholds favor fewer splits and longer buffers, potentially increasing truncation. Boundary errors can also affect subsequent predictions through the buffer: false positives fragment coherent context, while false negatives mix unrelated topics. Changing τ\tau therefore alters both boundary decisions and subsequent buffers. Table 7 uses model-predicted buffers, so its scores incorporate these downstream effects.

Table 7 evaluates incremental segmentation using model-predicted buffers and the actual input-truncation procedure, covering BERT, RoBERTa, and ModernBERT across multiple thresholds. F1 measures exact boundary matching, W-F1 allows a one-turn boundary offset, and BOR measures the ratio of predicted to reference boundary counts. For BERT, increasing τ\tau from 0.15 to 0.25 reduces BOR from 1.266 to 1.100, while F1 remains within 0.475–0.497 and W-F1 within 0.592–0.600. Similar stability holds for the other backbones: RoBERTa’s F1 and W-F1 range from 0.442–0.479 and 0.645–0.658, respectively, while ModernBERT’s range from 0.470–0.482 and 0.594–0.600.

Together, these results demonstrate stable boundary-matching quality across the tested thresholds for all three backbones, supporting robustness to threshold variations during incremental inference under the evaluated truncation procedure. The direct transfer to PersonaMem reported in W2 provides complementary evidence of effectiveness on long conversational histories.

Minor Concern: Clarifying score aggregation within segments

Minor concern: Figure 2 could more clearly show how message-level scores are aggregated into segment-level scores, making the retrieval pipeline easier to follow.

We provide an illustration of this process in Figure 8 (Appendix F.8) of the revised manuscript.

The message-to-segment aggregation refines each segment's dense embedding score through the following steps:

  1. Stage I: segment-level scoring. We encode the segment content into segment-level embeddings and combine their cosine similarities with the query embedding to obtain its initial dense score.
  2. Stage II: message-level scoring. For each candidate segment, we compute query–message cosine similarities using the same embedding model, then weight user and assistant scores by 0.7 and 0.3, respectively.
  3. Dense-score refinement. We average the two highest weighted message-level scores within each segment (K2=2K_2=2). This average replaces its Stage I dense score for subsequent score fusion and reranking.
AuthorsOpenReview ↗

A Gentle Follow-up on Our Rebuttal

Dear reviewer 6hYR,

Thank you again for your time and thoughtful review. With approximately one day remaining in the ICLR rebuttal period, we would like to follow up and check whether our responses have adequately addressed your concerns. If any questions or concerns remain, we would be happy to provide further clarification and address them before the discussion closes.

I sincerely appreciate the detailed replies from the authors, which have addressed most of my concerns. My major concern revolving implementations have been resolved, and I have adjusted my soundness assessment accordingly.

Reviewer_T1JAOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes Threader, a conversational memory system that preserves raw dialogue rather than rewriting it into memory entries. It uses Incremental Topic-Coherent Segmentation to group incoming dialogue by topic, and Multi-View Segment Representation to index each group using user messages, assistant replies, and both together. It then finds and ranks relevant passages and gives the selected original text to the language model to answer the question. Experiments evaluate answer accuracy, evidence recall, and construction and retrieval overhead on LongMemEval and PersonaMem with multiple model configurations.

Critical strengths

(S1) Threader achieves the highest overall accuracy on both datasets with both GPT-5-nano and GPT-5-mini. With GPT-5-mini, Threader improves LongMemEval accuracy from 84.80% to 90.60% and PersonaMem accuracy from 65.20% to 69.95% over the strongest reported baselines.

(S2) The paper includes useful comparisons within its own retrieval pipeline. Table 3 reports 90.60% accuracy versus 87.00% without segmentation, while Table 14 reports 69.95% versus 67.40% with fixed-size chunks. These results provide evidence that the learned segmentation helps beyond simply retaining raw dialogue.

(S3) Practical lightweight design. Table 4 reports substantially lower construction overhead than the rewrite-heavy systems, without generative LLM calls during indexing or retrieval. The additional model configurations and direct transfer of the segmenter to PersonaMem also broaden the evaluation.

Critical weaknesses

(W1) Figure 1 changes both the size and frequency of memory writes by merging sessions. Without testing the same writer on smaller segments, the results cannot distinguish a limitation of memory abstraction from a problem with write granularity.

(W2) Table 3 compares different retrieval units at the same Top-K without reporting reader-input tokens, leaving context size as another explanation for the gains. Table 4 also excludes final generation tokens, so end-to-end cost seems unclear.

(W3) In Section 3.1, SECOM already retrieves original dialogue organized by topic, but is not evaluated. The fixed-chunk controls do not establish Threader’s advance over this closer design, leaving its main methodological contribution not clear.

(W4) The multi-view ablation in Table 3 uses dense-only retrieval. Table 13 tests the full pipeline only after reducing K1K_1 from 40 to 10, leaving its contribution under the default configuration unclear.

Questions for authors

(Q1) For the claim in Section 1 and Figure 1, does the degradation persist when the same Mem0 and MemU writers process bounded-size inputs or Threader’s topic-coherent segments instead of whole concatenated sessions? Please report evidence retention and QA accuracy to distinguish abstraction loss from ingestion-granularity effects.

(Q2) In Section 4.3, Table 3, how do the segmentation and message-versus-segment variants compare at matched actual reader-input token budgets? Can the Section 4.5 cost comparison also include final response-generation tokens?

(Q3) Section 3.1 discusses SECOM, but Section 4.1 does not evaluate it. Under shared reader models and comparable retrieved-token budgets, what accuracy–cost advantage does Threader retain over this evidence-preserving topical-segment approach?

(Q4) For the multi-view component in Section 3.2 and Table 3, what are the full-pipeline results with and without multi-view representations at the default (K1K_1=40), keeping BM25, message-level scoring, reranking, and the final Top-K unchanged?

5 comments
AuthorsOpenReview ↗

Response to W1 & Q1

We appreciate your insightful questions! We address your comments point by point below.

W1/Q1: Evidence loss under finer write granularity

(W1) Figure 1 changes both the size and frequency of memory writes by merging sessions. Without testing the same writer on smaller segments, the results cannot distinguish a limitation of memory abstraction from a problem with write granularity.

(Q1) For the claim in Section 1 and Figure 1, does the degradation persist when the same Mem0 and MemU writers process bounded-size inputs or Threader’s topic-coherent segments instead of whole concatenated sessions? Please report evidence retention and QA accuracy to distinguish abstraction loss from ingestion-granularity effects.

On the same 60 samples used in Figure 1, we fed Threader-generated topic segments into the unchanged Mem0 and MemU writers, yielding 2.43× finer write granularity. We then manually annotated evidence retention using the original protocol. For comparison, we also include the original concatenation results from Figure 1 (Mem0) and Appendix F.1 (MemU). All numerical results below are percentages.

MethodWriter inputFully retained (%)Partially retained (%)Completely missing (%)Accuracy (%)
Mem01-concat (orginal)75.08.316.755.0
Mem02-concat43.320.036.726.7
Mem04-concat28.315.056.721.7
Mem08-concat11.76.781.75.0
Mem0Threader segments60.031.78.356.7
MemU1-concat (original)75.05.020.063.3
MemU2-concat53.38.338.338.3
MemU4-concat56.710.033.348.3
MemU8-concat28.316.755.025.0
MemUThreader segments88.310.01.768.3

Write granularity affects retention, but finer ingestion does not eliminate evidence loss: required evidence remains incomplete in 40.0% of Mem0 cases and 11.7% of MemU cases even with Threader-generated inputs. Threader achieves 93.3% accuracy on the same samples, supporting the value of evidence preservation.

AuthorsOpenReview ↗

Response to W2 & Q2

W2/Q2: Matched context budgets and generation costs

(W2) Table 3 compares different retrieval units at the same Top-K without reporting reader-input tokens, leaving context size as another explanation for the gains. Table 4 also excludes final generation tokens, so end-to-end cost seems unclear.

(Q2) In Section 4.3, Table 3, how do the segmentation and message-versus-segment variants compare at matched actual reader-input token budgets? Can the Section 4.5 cost comparison also include final response-generation tokens?

  1. Reader-input token control in Ablation Study (Table 3). We apologize for the unclear description in ablation studies. In Table 3, all segmentation ablations and the Message Unit variant are matched to Threader's reader-input token counts at Top-5 and Top-12. These labels refer to Threader's reference settings, with context budgets matched across the compared variants. For the multi-view representation and retrieval-signal ablations, all variants use the same segment units and the same retrieval budgets of 5 or 12 segments. We have clarified this budget control in Section 4.3 in the revised manuscript.

  2. Query and response costs in table 4. We additionally report final response-input tokens and their associated cost, complementing the query-stage costs in Table 4. The table below, also included as Table 17 in Appendix F.9 of the revised manuscript, combines query-stage and response-input costs per question with the corresponding LongMemEval accuracy. Final responses are brief and have similar output-token counts across methods. Their output costs are small and comparable, and are therefore excluded from the table.

MethodQuery in tok.Query out tok.Response in tok.Combined cost ($ /query)Acc. (%)
Self-RAG2.3K0.4K10.9K0.004376.60
HippoRAG217.5K0.7K14.0K0.011675.00
SeCom0014.7K0.003780.80
Mem0003.7K0.000957.20
MemU16.1K2.5K3.7K0.012171.60
A-Mem9.9K0.9K9.6K0.007867.20
EverMemOS3.1K0.3K4.1K0.002784.80
Threader (Top-7)009.3K0.002385.40
Threader (Top-12)0015.3K0.003890.60

Preserving raw evidence can increase response-input tokens, but Threader requires no query-stage LLM tokens, keeping the combined cost low. At Top-12, Threader costs more than EverMemOS and SeCom but improves accuracy by 5.80 and 9.80 percentage points, respectively, while avoiding their substantial LLM-based memory-construction overhead. At Top-7, it costs $ 0.0023 per query and outperforms all baselines in accuracy. Only Mem0 is cheaper ($ 0.0009), but its accuracy is 57.20% versus Threader's 85.40%. Threader offers a favorable trade-off among cost, latency, and accuracy, combining low cost and fast retrieval with high answer accuracy.

AuthorsOpenReview ↗

Response to W3 & Q3

W3/Q3: SeCom comparison under comparable retrieved-context token budgets

(W3) In Section 3.1, SECOM already retrieves original dialogue organized by topic, but is not evaluated. The fixed-chunk controls do not establish Threader’s advance over this closer design, leaving its main methodological contribution not clear.

(Q3) Section 3.1 discusses SECOM, but Section 4.1 does not evaluate it. Under shared reader models and comparable retrieved-token budgets, what accuracy–cost advantage does Threader retain over this evidence-preserving topical-segment approach?

Threader and SeCom Both retrieve topic-organized dialogue. The key differences are:

  • Segmentation and scalability: SeCom relies on LLM-prompted segmentation, whose quality can be sensitive to the choice of LLM; Threader makes incremental boundary decisions with a lightweight segmenter, supporting long, evolving real-world histories without segmentation-related LLM calls.
  • Memory representation: SeCom uses compression-based denoising for retrieval; Threader retains raw evidence and constructs user-only, assistant-only, and full-interaction views to expose role-specific signals.
  • Evidence retrieval: SeCom scores segment-level memory units; Threader refines relevance using role-weighted message scores, then combines dense, lexical, and reranking signals to retrieve coherent segments, yielding more effective yet lightweight retrieval.

We additionally evaluated SeCom on LongMemEval using the same response models and comparable retrieved-context token budgets:

MethodGPT-5-nano accuracy (%)GPT-5-mini accuracy (%)Qwen3.5-plus accuracy (%)
SeCom75.0080.8055.60
Threader80.6090.6087.00

Threader outperforms SeCom across all three backbones, with gains of 5.60 and 9.80 percentage points on GPT-5-nano and GPT-5-mini, respectively. The advantage is especially pronounced on Qwen3.5-plus, reaching 31.40 percentage points (87.00% vs. 55.60%).

On PersonaMem, SeCom's prompt-based segmenter could not process the long sessions in our tested configuration, while Threader's incremental segmenter succeeded.

Construction takes 18.33 s for Threader versus 127.28 s for SeCom per 100K input tokens; Threader also avoids SeCom's $0.0702 LLM segmentation cost. Retrieval latency is comparable (8.66 s for Threader versus 8.13 s for SeCom). Query and response-input costs are reported in W2/Q2.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.