acceptodds
Under review as a conference paper at ICLR 2027

RECURRENT READING FOR SINGLE-VECTOR RETRIEVAL

31 views

Abstract

In reasoning-intensive retrieval, a relevant document may share an underlying principle with the query rather than its words, requiring several points of contact between query and document. Late-interaction models provide this capacity but incur additional cost at retrieval time. We ask whether a single vector representation can instead be trained to encode this information. In our aligned-score configurations with untied output projections, we observe slot locking: corresponding query and document reads attain the highest similarity, and the additional reads partly compensate for a weakened base embedding. We introduce Recurrent Reading for Single-Vector Retrieval (RLI), which reads token states with a recurrent head and matches each query read to its best document read through a projection shared across reads. We find that late interaction is more useful as a training signal than as a scoring rule. At retrieval time, RLI ranks documents using one inner product between the packed query and document vectors. Across four backbones from 0.6B to 4B and three model families, removing the reads from the trained model costs to nDCG@10. On BRIGHT, using original queries without query-time generation or reranking, a 4B RLI averages nDCG@10 over three seeds (best ), points above the strongest published retriever-only baseline in our comparison and above the same recipe without reads ().

Primary area:
unsupervised, self-supervised, semi-supervised, and supervised representation learning
Keywords:
dense retrieval, late interaction, text embeddings, contrastive learning, reasoning-intensive retrieval

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_dSwbOpenReview ↗
Rating
3
Confidence
4
Informativeness
3
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes Recurrent Reading for Single-Vector Retrieval (RLI) to address the limitations of single-vector representations in reasoning-intensive retrieval. Existing multi-vector retrieval performs fine-grained relevance matching through late interaction among multiple token representations, but incurs high index storage and retrieval costs. The authors analyze the slot locking phenomenon that arises from simply concatenating multiple pooled representations. The problem is that, as each query read is trained to correspond only to the document read at the same position, the benefits of cross-read matching are not fully exploited. RLI uses a GRU-based recurrent read head and a shared projection, and applies cross-read MaxSim during training. At actual retrieval, multiple reads are combined into a single vector and only a single inner product is performed. On BRIGHT, the 4B model achieves 42.42 nDCG@10, 3.62 points higher than the baseline with reads removed under the same training recipe (38.80).

Critical strengths
  1. RLI uses late interaction during training while retaining single-vector retrieval at inference. Unlike conventional multi-vector retrieval methods such as ColBERT, this design benefits from cross-read matching without requiring a multi-vector index.
  2. The analysis of slot locking provides a clear motivation for the proposed method. The authors support this observation with off-diagonal argmax rates, read cosine similarity, and scoring function comparisons. The ablation studies further help isolate the effects of the shared projection and training objective.
  3. The paper identifies a limitation of aligned dot-product scoring in concatenated representations and addresses it through cross-read MaxSim supervision. This is a useful contribution beyond simply introducing another retrieval architecture.
  4. RLI offers a practical way to improve reasoning-intensive retrieval while preserving the simplicity of single-vector search. The results on BRIGHT suggest that the proposed training strategy can improve retrieval quality without introducing query-time late interaction.
Critical weaknesses
  1. The independent contribution of recurrent reading is relatively small. A single learned read achieves 42.46 nDCG@10, nearly identical to the 3-read RLI average of 42.42. This suggests that a substantial portion of the core performance gain comes from the additional learned representation itself rather than from the recurrent multi-read interaction. A clearer analysis appears necessary.
  2. Empirical analysis of single-vector efficiency is lacking. Although RLI maintains a single-vector index, the vector dimension increases from 2,560 to 3,328, by about 30%. Measuring the actual index memory and retrieval latency would make the efficiency claim clearer.
Questions for authors
  1. Given that a single learned read performs similarly to the 3-read RLI, what is the main advantage of the recurrent multi-read architecture? I am curious about differences depending on read diversity or query complexity.
  2. Recommend briefly discussing the difference from LEMUR [1] in the Related Work, which would make the contribution clearer.

[1] Elias Jääsaari et al. "LEMUR: Learned Multi-Vector Retrieval." In Proceedings of the 43rd International Conference on Machine Learning (ICML), arXiv preprint arXiv:2601.21853 (2026).

4 comments
AuthorsOpenReview ↗

Response Part #1

Comment 1 of 5

W1: one learned read vs. the three-read RLI

Thank you for the careful reading and helpful questions. Our T=1 model is a parameter-matched control: the GRU and W_o are shared across reads, so the read head has the same 3.28M parameters for every T. Only the number of read steps changes.

The 42.46 in the review is a single T=1 run (seed 44), while 42.42 is RLI's three-seed mean. At the same seed, data and recipe, RLI scores 43.41, +0.95 nDCG@10 over one read (95% CI [0.32, 1.60]; paired bootstrap over queries), and is better on 8 of 12 domains. The table also shows where the gain comes from: three reads without the cross-read maximum (G) or without recurrence (H) score below one read. BRIGHT nDCG@10, seed 44:

DomainOne read (T=1)3 reads, no cross-read max (G)3 reads, no recurrence (H)RLI (T=3)RLI − T=1
Biology68.2266.2368.4670.30+2.08
Earth Sci.62.6562.5664.1164.26+1.61
Economics39.8237.5538.2038.51−1.31
Psychology46.1944.7845.6149.03+2.85
Robotics34.1031.7431.8333.93−0.17
Stack Ov.39.3138.7539.2841.55+2.25
Sus. Liv.40.4340.1939.0941.18+0.75
LeetCode26.4627.0525.7129.34+2.88
Pony43.8343.7437.7545.47+1.63
AoPS17.5517.1618.5419.04+1.49
TheoQ.41.4741.2741.2139.07−2.40
TheoT.49.4747.1447.7949.25−0.22
Avg.42.4641.5141.4643.41+0.95

So extra reads do not help just by adding vectors. If either ingredient is missing, they cost about one point (G −0.95, [−1.47, −0.42]; H −0.99, [−1.63, −0.36]). With both, recurrence and training through the cross-read maximum, they help: RLI beats the non-recurrent reads by +1.95 ([1.27, 2.64]), on 11 of 12 domains.


Comment 2 of 5

W1 (continued): same result on a second training mixture

To check that this does not depend on our data, we retrained T=1 and T=3 on a second public mixture: the ReasonEmbed release plus about 7.5k real StackExchange, LeetCode, ReasonRank and NuminaMath questions. No row comes from a BRIGHT query or label. T=3 again beats one read, by +0.74 nDCG@10 (95% CI [0.18, 1.32]), on 8 of 12 domains:

DomainOne read (T=1)RLI (T=3)Δ
Biology68.2568.85+0.60
Earth Sci.62.9464.35+1.41
Economics35.6235.68+0.06
Psychology46.7050.24+3.54
Robotics35.0632.97−2.09
Stack Ov.39.6541.77+2.12
Sus. Liv.40.7739.10−1.68
LeetCode52.7553.37+0.62
Pony50.9655.98+5.02
AoPS14.4615.69+1.23
TheoQ.38.7537.06−1.70
TheoT.46.7146.47−0.24
Avg.44.3945.13+0.74

These intervals cover query sampling, not seed noise (about one point on BRIGHT, which is why the main result uses three seeds). What holds on both mixtures is that three recurrent reads beat one. Badly designed extra reads hurt by much more than this noise: three slot-locked reads (aligned loss, untied W_o; configuration C, original mixture) are 3.05 below one read (95% CI [−3.86, −2.26]).


AuthorsOpenReview ↗

Response Part #2

Comment 3 of 5

Q1: the advantage of recurrent multi-read reading; read diversity and query complexity

Main advantage. Recurrence is what makes extra reads useful. Each read sees what the earlier reads attended to, and the cross-read maximum lets a query read match whichever document read holds the same evidence. Without either, three reads fall below one (Comment 1). Most of the benefit comes with the second read (T=2 43.37, T=3 43.41), and T=2 stores 7.7% fewer floats per document.

Read diversity. Table 2 of the paper (Section 4.3) measures how reads are used at inference on BRIGHT. The off-diagonal argmax rate is the share of query reads, over all (query, gold document) pairs, whose best-matching document read is not the aligned one (0% = slot-locked, 66.7% = uniform at T=3):

Config.Training objectiveTied W_oOff-diagonal argmax rateRead cosine
Baligned dotno0.0%−0.04
Caligned dotno0.0%−0.03
Ecross-read maxno0.0%−0.00
Galigned dotyes10.3%0.84
F (RLI)cross-read maxyes37.1%0.88

Untied reads only look diverse (cosine ≈ 0) because they sit in unrelated subspaces, so a query read never matches another document read better, even with the cross-read maximum (E). RLI's reads share one space but attend to different parts: 37% of query reads find their best match in a different document read, which one read cannot do. RLI is the only configuration with real cross-read matching, and the only one above a single read.

Query complexity. Using query length as a proxy, we split each domain's queries into three equal-size groups and recompute the gain of RLI over the non-recurrent reads (H; domain-macro, paired bootstrap, seed 44):

Query length (tercile within each domain)Median wordsQueriesRLI − non-recurrent reads H, nDCG@10 (95% CI)
Short50454+2.45 [+1.26, +3.65]
Medium84457+1.44 [+0.23, +2.65]
Long142473+1.97 [+0.93, +3.06]

Comment 4 of 5

W2: index memory and latency (measured)

We measured the deployed RLI-4B (seed 44) on one H100 GPU (CPU on the same node), with exhaustive inner-product search as in the paper. The read head has 3.28M parameters (0.08% of the backbone).

Index memory. A flat index takes N × d × 4 bytes in fp32 (half in fp16); our FAISS measurement on the largest BRIGHT corpus matches this:

Stored vectorDimsBytes / doc (fp32)Index, 1M docs (fp32)Index, LeetCode corpus 414k docs: measured (FAISS flat)BRIGHT nDCG@10 (seed 44)
Base vector only (reads switched off)2,56010,24010.24 GB4.24 GB38.94
T=12,81611,26411.26 GB4.66 GB42.46
T=23,07212,28812.29 GB5.09 GB43.37
T=3 (RLI)3,32813,31213.31 GB5.51 GB43.41

Encoding. The read head runs on token states the backbone has already computed. On 2,000 BRIGHT documents (267 tokens on average, batch 8), it adds 1.3% to encoding time (87.0 documents/s with the head vs. 88.1 without). One query takes 26.5 ms with the reads vs. 25.6 ms without (median over 195 queries).

Search latency, 1M documents, top-100, median (GPU: fp16 matrix product; CPU: FAISS IndexFlatIP, fp32, 16 threads):

Stored vectorDimsGPU, 1 query (ms)GPU, per query in a batch of 128 (ms)CPU, 1 query (ms)
Base vector only (reads switched off)2,5602.610.030285.4
T=12,8162.860.032327.8
T=23,0723.110.034356.3
T=3 (RLI)3,3283.350.036387.9

Search cost grows with vector size: T=3 takes 20–36% more time than the base vector alone, in line with its 30% larger dimension, while T=2 gives the same accuracy (43.37 vs. 43.41) at +20%. The index is still one vector per document, so standard approximate search and quantization apply. Late interaction, by contrast, stores one vector per token, and these documents average 267 tokens. We will add these numbers to the paper.


Comment 5 of 5

Q2: LEMUR (Jääsaari et al., ICML 2026)

This is a very useful reference to know about, and we agree that discussing it will help clarify our contribution. We will add a brief comparison with LEMUR in the Related Work section.

We hope this addresses your concerns. The revision will add the matched-seed table and its replication, the read-usage and query-length analyses, the efficiency numbers, and the LEMUR discussion.

Dear Reviewer,

we hope you have a chance to check our response above. Please let us know if you need any further clarification or another experiment before the deadline

thank you!

Reviewer_dSwbOpenReview ↗

Response

I have received the rebuttal response and thank you for the response and extra experiments. After careful consideration, I keep my score.

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

The authors propose Recurrent Reading for Single-Vector Retrieval (RLI) to improve retrieval accuracy on reasoning-intensive retrieval tasks. RLI uses recurrent attention-pooling head (i.e., GRU) to generate additional vectors and concatenate them to the embedding representation generated from the backbone embedding model. During training, RLI uses MaxSim operation to prevent slot locking, where the representation vectors from recurrent attention-pooling head are matched primarily by fixed positions. At inference, RLI concatenates the base embedding and the auxiliary vectors to compute similarity with ordinary dot product. On BRIGHT benchmark dataset, RLI achieves 42.42 nDCG@10 accuracy, which is the highest accuracy among single vector retrieval.

Critical strengths

S1. Retrieval accuracy improvement.

The authors show that RLI improves BRIGHT nDCG@10 by around 3.65 points. The authors show that we can further generate more meaningful representation with recurrent attention-pooling head. The authors conduct experiments to show that the improvement in the accuracy is consistent with four different backbones.

S2. Interesting idea of using MaxSim for training single vector retrieval.

The authors empirically show that we can train a better representations from recurrent attention-pooling heads when combining with the MaxSim operations.

Critical weaknesses

W1. Slot locking seems like a marginal problem.

The authors state that their main contribution is identifying slot locking and proposing solution for it. However, it seems slot locking is a marginal problem. Specifically, most of the improvement in retrieval accuracy is coming from adding recurrent attention-pooling head, instead of solving the slot locking. Section 4.5 explains that with T=1, RLI already achieves the accuracy of 42.42.

W2. Experiments needs to be more comprehensive. The authors conduct experiments on BRIGHT benchmark dataset only. Experiments in other retrieval datasets (e.g., BEIR) would help to understand if RLI is generally helpful even to non reasoning-intensive retrieval. Furthermore, applying LRI on other reasoning-intensive retrieval methods (e.g., query rewriting) would help better understand if RLI is generally helpful along with other methods.

W3. Presentation needs significant improvement.

The paper is difficult to follow. Many terms are used without clear definition. For instance, the model variants (e.g., A, B, C, ...) are used through out the paper, but the definition is in Figure 5. Also, experiments are reported with mix of three-seed means and selected single runs, which makes it difficult to compare.

Questions for authors

Q1. Does RLI show better accuracy when compared with other related methods (e.g., query rewriting) that targets reasoning intensive retrieval? Can RLI be used along with other methods and still be effective in terms of improving retrieval accuracy?

Q2. Does RLU also improve the retrieval accuracy on non-reasoning intensive retrieval (e.g., BEIR)?

Q3. What are the measured encoding latency, retrieval latency, and index storage costs compared with the read-free baseline?

8 comments
AuthorsOpenReview ↗

Response Part #1

Comment 1 of 6

W1: slot locking decides whether additional reads help

We thank the reviewer for the detailed review. The sentence in Section 4.5 invites this reading and we will rewrite it: it sets a single T=1 run (42.46, seed 44) against RLI's three-seed mean (42.42). Matched on seed, data and recipe, RLI scores 43.41, +0.95 (95% CI [0.32, 1.60]) over one read, query-paired bootstrap with 10K resamples stratified by domain.

The reviewer is right that one learned read carries most of the gain over read-free training; the paper says so in Section 4.5. Slot locking is what decides whether reads beyond the first add or subtract.

T=1 cannot show what slot locking costs: with one read per side there is a single possible pairing, so the aligned and cross-read objectives coincide. The cost appears as soon as there are several reads. Trained with the aligned objective, three reads are slot-locked (0% off-diagonal matches) and score well below one read; tying W_o unlocks them only partly and they stay below one read; RLI's cross-read objective unlocks them and they exceed it. BRIGHT nDCG@10, seed 44, same backbone, data and recipe:

DomainOne read (T=1)3 reads, aligned loss, untied W_o (C)3 reads, aligned loss, tied W_o (G)3 reads, RLI (F)F − C
Biology68.2263.0966.2370.30+7.21
Earth Sci.62.6558.9762.5664.26+5.29
Economics39.8234.2637.5538.51+4.24
Psychology46.1943.8944.7849.03+5.14
Robotics34.1032.7731.7433.93+1.16
Stack Ov.39.3137.0038.7541.55+4.55
Sus. Liv.40.4339.3240.1941.18+1.86
LeetCode26.4626.2927.0529.34+3.06
Pony43.8333.7343.7445.47+11.74
AoPS17.5516.9017.1619.04+2.14
TheoQ.41.4739.9341.2739.07−0.86
TheoT.49.4746.7147.1449.25+2.54
Avg.42.4639.4241.5143.41+4.01
Off-diagonal argmax raten/a (one read)0.0%10.3%37.1%

Removing slot locking turns −3.05 against one read (C, 95% CI [−3.86, −2.26]) into +0.95 (F): F − C = +4.01 (95% CI [3.08, 4.93]), better on 11 of 12 domains.

The gain over one read also holds on a second public training mixture with the same recipe (ReasonEmbed plus about 7.5k real StackExchange, LeetCode, ReasonRank and NuminaMath questions): T=3 beats T=1 by +0.74 (95% CI [0.18, 1.32]).


Comment 2 of 6

W2 / Q1: RLI and query rewriting

BRIGHT provides LLM-generated reasoning for each query as its rewriting setting. We use the GPT-4, Claude-3-Opus and Llama-3-70B versions, and score each with the base vector alone (reads off; 38.94 on original queries, close to the read-free model's 38.80) and with the packed vector. BRIGHT nDCG@10, seed 44:

DomainOriginal query: base vectorOriginal query: RLIGPT-4 reasoning appended: base vectorGPT-4 reasoning appended: RLIGPT-4 reasoning replaces query: base vectorGPT-4 reasoning replaces query: RLI
Biology65.1670.3068.2772.9166.9871.41
Earth Sci.59.7964.2664.3768.2264.3968.47
Economics35.6338.5135.6337.7532.7936.13
Psychology40.5649.0344.9549.4544.6446.06
Robotics29.7533.9333.1333.4029.8532.62
Stack Ov.35.3441.5538.2143.6538.6741.97
Sus. Liv.38.2141.1839.5240.5338.0838.44
LeetCode21.0729.3421.6728.2919.4022.57
Pony38.1645.4747.5551.3847.5752.00
AoPS13.2219.0415.8319.5714.4917.51
TheoQ.41.6339.0740.7038.3039.2537.03
TheoT.48.7449.2543.4744.9442.3742.97
Avg.38.9443.4141.1144.0339.8742.27

Claude-3-Opus and Llama-3-70B reasoning, replacing the query:

DomainClaude-3-Opus reasoning: base vectorClaude-3-Opus reasoning: RLILlama-3-70B reasoning: base vectorLlama-3-70B reasoning: RLI
Biology67.4770.8066.8568.94
Earth Sci.65.0369.0462.6367.35
Economics33.1135.3733.7237.63
Psychology43.5449.2042.4644.76
Robotics31.5433.9031.5034.81
Stack Ov.39.3443.5737.1644.22
Sus. Liv.38.8039.1237.4538.72
LeetCode19.3223.2419.5224.13
Pony51.0354.2146.5352.92
AoPS11.8714.8212.5115.32
TheoQ.40.2038.9538.9037.38
TheoT.42.2443.9444.1145.95
Avg.40.2943.0139.4542.68

Compared with rewriting. RLI on original queries (43.41) beats every rewriting setting without reads, including the best one (GPT-4 appended, 41.11), by +2.30 (95% CI [1.23, 3.42]), with no LLM call at query time.

AuthorsOpenReview ↗

Response Part #2


Comment 3 of 6

W2 / Q2: results beyond BRIGHT (1/2): BRIGHT-Pro

We tested our model on two more reasoning benchmarks.

BRIGHT-Pro (739 queries, 7 domains, mostly new gold documents). MTEB code, α-nDCG@25 (main metric):

DomainBM25ReasonIR-8BQwen3-Emb.-8BRTriever-4BDIVER-4B-1020BGE-Reasoner-8BRLI-4B, base vectorRLI-4B
Biology41.942.652.763.172.873.579.681.5
Earth Sci.49.152.258.664.772.174.678.080.0
Economics40.234.946.053.661.966.067.371.3
Psychology30.635.646.650.159.965.564.369.3
Robotics39.240.948.449.256.764.764.467.9
Stack Ov.40.245.752.852.763.867.768.171.0
Sus. Liv.40.735.141.053.958.863.866.468.8
Avg.40.341.049.555.363.768.069.772.8

RLI-4B is the best retriever on all 7 domains, ahead of 8B models, and the reads add +3.1 over its already strong base vector. In nDCG@10 the gain holds on all 7 domains, both for the submitted model and for the second mixture of Comment 1 (vs. a same-recipe no-reads model, MTEB version):

DomainSubmitted: base vectorSubmitted: RLIΔ2nd mixture: no reads2nd mixture: RLIΔ
Biology73.376.6+3.372.076.2+4.2
Earth Sci.72.074.8+2.871.273.6+2.3
Economics59.364.0+4.860.064.1+4.1
Psychology57.462.7+5.360.164.8+4.7
Robotics55.859.6+3.858.860.5+1.7
Stack Ov.63.367.4+4.061.969.4+7.5
Sus. Liv.59.963.1+3.259.161.5+2.4
Avg.63.066.9+3.963.367.2+3.8

Comment 4 of 6

W2 / Q2: results beyond BRIGHT (2/2): TEMPO, and non-reasoning retrieval

TEMPO (temporal reasoning retrieval, 13 domains, 1,730 queries, nDCG@10), no TEMPO training data:

DomainBM25GritLM-7BReasonIR-8BRaDeR-7BSFR-MistralE5-Mistral-7BRLI-4B, base vectorRLI-4B
Bitcoin6.219.116.314.917.616.313.410.8
Cardano13.421.722.918.628.135.722.729.4
IOTA9.736.641.719.237.141.729.437.2
Monero2.814.719.621.023.720.018.213.9
Economics5.817.220.022.721.925.027.434.1
Law12.738.337.933.540.834.034.227.7
Politics32.741.435.432.444.947.947.455.3
History9.227.334.325.832.428.735.037.2
Quant2.521.619.527.816.813.815.814.9
Travel4.625.021.426.129.728.320.816.2
Workplace6.230.830.036.631.632.935.545.7
Genealogy13.326.930.318.731.733.530.034.0
HSM21.233.424.716.933.537.727.536.8
Avg.10.827.227.224.230.030.427.530.2

The reads add +2.8 over the base vector and improve 8 of 13 domains.

Non-reasoning retrieval (Q2). RLI targets reasoning-intensive retrieval, where a document must match the query on several points; we do not claim gains on mostly topical data such as BEIR. There is a simple fallback: all stored vectors have the same norm, so setting the query's read block to zero ranks documents exactly by the base embedding, from the same index and with no re-encoding. The reads can thus be switched off per collection.

AuthorsOpenReview ↗

Response Part #3


Comment 5 of 6

Q3: encoding latency, retrieval latency and index storage vs. the read-free baseline (measured)

We measured the RLI-4B (seed 44) on one H100 GPU (CPU on the same node), with inner-product search as in the paper. The read-free baseline stores the 2,560-dim base vector of the same backbone, so its costs are the first row of each table. The read head has 3.28M parameters (0.08% of the backbone).

Index storage. A flat index takes N × d × 4 bytes in fp32 (half in fp16); our FAISS measurement on the largest BRIGHT corpus matches this:

Stored vectorDimsBytes / doc (fp32)Index, 1M docs (fp32)Index, LeetCode corpus 414k docs: measured (FAISS flat)BRIGHT nDCG@10 (seed 44)
Read-free size (RLI's base vector alone)2,56010,24010.24 GB4.24 GB38.94
T=12,81611,26411.26 GB4.66 GB42.46
T=23,07212,28812.29 GB5.09 GB43.37
T=3 (RLI)3,32813,31213.31 GB5.51 GB43.41

Encoding latency. The read head runs on token states the backbone has already computed. On 2,000 BRIGHT documents (267 tokens on average, batch 8), it adds 1.3% to encoding time (87.0 documents/s with the head vs. 88.1 without). One query takes 26.5 ms with the reads vs. 25.6 ms without (median over 195 queries).

Retrieval latency, 1M documents, top-100, median (GPU: fp16 matrix product; CPU: FAISS IndexFlatIP, fp32, 16 threads):

Stored vectorDimsGPU, 1 query (ms)GPU, per query in a batch of 128 (ms)CPU, 1 query (ms)
Read-free size (RLI's base vector alone)2,5602.610.030285.4
T=12,8162.860.032327.8
T=23,0723.110.034356.3
T=3 (RLI)3,3283.350.036387.9

Search cost grows with vector size: T=3 takes 20–36% more time than the read-free vector, in line with its 30% larger dimension, while T=2 gives the same accuracy (43.37 vs. 43.41) at +20%. The index is still one vector per document, so standard approximate search and quantization apply. We will add these numbers to the paper.


Comment 6 of 6

W3: presentation

We agree and will restructure Section 4. The configurations are now defined only in a figure caption; the revision will open Section 4 with this table and name each configuration by its description, not only its letter. BRIGHT nDCG@10; "base vector" is the run's base embedding alone, "reads add" is the packed vector's gain over it.

We hope this addresses your concerns. The revision will add the matched-seed and slot-locking analysis, the rewriting results, BRIGHT-Pro, TEMPO and the efficiency numbers.

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

The paper proposes RLI, which uses a recurrent head to read multiple views of query and document token states. Late-interaction matching is used during training, while retrieval uses a packed single-vector inner product. The authors report improvements on BRIGHT across several backbones and analyze how read alignment affects retrieval.

Critical strengths

1, The paper addresses a meaningful retrieval trade-off. It aims to capture multi-point query–document matching while retaining a single-vector retrieval interface. 2, The analysis examines the mechanism rather than only final scores. Slot alignment, scorer choice, and read-count sensitivity are investigated.

Critical weaknesses

1, The contribution of multiple reads is not fully isolated. The paper reports that a one-read configuration is close to the multi-read mean, leaving unclear whether the main benefit comes from recurrent multi-read structure or from adding a learned read to the base embedding. 2, The strongest evidence is concentrated on BRIGHT. Results on other retrieval settings would help establish whether the method addresses a broader limitation of single-vector retrieval or is especially suited to reasoning-intensive queries.

Questions for authors

1, What benefit do multiple recurrent reads provide over a parameter-matched single-read model? 2, Does RLI improve retrieval on benchmarks beyond BRIGHT, particularly where relevance depends less on multi-step reasoning?

4 comments
AuthorsOpenReview ↗

Response Part #1

Comment 1 of 4

W1 / Q1: multiple recurrent reads vs. a parameter-matched single read

Thank you for raising this point. The T=1 model is the parameter-matched single-read control: the GRU is shared across read steps and the output projection W_o is tied, so the read head has the same parameters for every T; only the number of recurrent steps changes.

The comparison you cite puts one T=1 run against the three-seed mean of T=3. At the same seed (44), we used paired bootstrap over queries with 10k resamples; we found that T=3 beats T=1 by +0.95 nDCG@10 (95% CI [0.32, 1.60]) and T=2 beats it by +0.91 ([0.29, 1.53]). Three reads without recurrence, which are mentioned in the paper (configuration H), fall below one read (−0.99, [−1.63, −0.36]):

DomainT=1T=2T=3 (RLI)3 reads, no recurrence (H)T=3 − T=1
Biology68.2270.1770.3068.46+2.08
Earth Sci.62.6564.0364.2664.11+1.61
Economics39.8238.7738.5138.20−1.31
Psychology46.1946.1249.0345.61+2.85
Robotics34.1032.4233.9331.83−0.17
Stack Ov.39.3139.7341.5539.28+2.25
Sus. Liv.40.4340.8741.1839.09+0.75
LeetCode26.4630.2029.3425.71+2.88
Pony43.8349.0445.4737.75+1.63
AoPS17.5519.6519.0418.54+1.49
TheoQ.41.4739.7839.0741.21−2.40
TheoT.49.4749.6249.2547.79−0.22
Avg.42.4643.3743.4141.46+0.95

So one learned read gives most of the gain (Section 4.5), and more reads add to it only when they are recurrent, i.e. each read sees what the earlier reads attended to. Extra read vectors alone do not help (H). Most of this extra gain already comes with the second read (T=2 ≈ T=3).


Comment 2 of 4

W1 / Q1 (continued): same result on a second training mixture

To check that this does not depend on our data, we retrained with the same recipe on a second public mixture: the ReasonEmbed release plus about 7.5k real StackExchange, LeetCode, ReasonRank and NuminaMath questions. No row comes from a BRIGHT query or label. BRIGHT nDCG@10 at two seeds:

DomainNo reads (s42)RLI (s42)ΔNo reads (s44)RLI (s44)Δ
Biology64.7070.46+5.7661.2268.85+7.63
Earth Sci.58.6863.37+4.6956.3164.35+8.04
Economics35.4835.86+0.3833.0335.68+2.65
Psychology47.7051.35+3.6544.9150.24+5.32
Robotics30.2035.46+5.2630.6432.97+2.32
Stack Ov.36.7242.48+5.7734.2341.77+7.55
Sus. Liv.38.2640.28+2.0336.2539.10+2.84
LeetCode53.7952.72−1.0652.5153.37+0.87
Pony29.9445.71+15.7733.9955.98+21.99
AoPS11.5114.50+2.9912.8815.69+2.81
TheoQ.40.5737.34−3.2339.8237.06−2.77
TheoT.44.8447.85+3.0144.6846.47+1.79
Avg.41.0344.78+3.7540.0445.13+5.09

The reads add +3.75 and +5.09 (10 and 11 of 12 domains), close to the +3.6 in the paper. RLI's base vector alone (40.67 / 40.25) is within 0.4 of the no-reads model, so the gain comes from the reads, not from a better base encoder.

T=3 again beats T=1, by +0.74 (95% CI [0.18, 1.32]), on 8 of 12 domains:

DomainT=1 (s44)T=3, RLI (s44)Δ
Biology68.2568.85+0.60
Earth Sci.62.9464.35+1.41
Economics35.6235.68+0.06
Psychology46.7050.24+3.54
Robotics35.0632.97−2.09
Stack Ov.39.6541.77+2.12
Sus. Liv.40.7739.10−1.68
LeetCode52.7553.37+0.62
Pony50.9655.98+5.02
AoPS14.4615.69+1.23
TheoQ.38.7537.06−1.70
TheoT.46.7146.47−0.24
Avg.44.3945.13+0.74

These intervals cover query sampling, not seed noise (about one point on BRIGHT, which is why the main result uses three seeds). What holds on both mixtures is that three recurrent reads beat one. Slot-locked reads hurt by much more than this noise: configuration C (original mixture) is 3.05 below one read (95% CI [−3.86, −2.26]).

AuthorsOpenReview ↗

Response Part #2


Comment 3 of 4

W2 / Q2: results beyond BRIGHT (1/2): BRIGHT-Pro

We tested on two more reasoning benchmarks that we never used during model design. As in the paper, all baselines are retrievers on original queries.

BRIGHT-Pro (739 queries, 7 domains) using MTEB and α-nDCG@25 (main metric):

DomainBM25ReasonIR-8BQwen3-Emb.-8BRTriever-4BDIVER-4B-1020BGE-Reasoner-8BRLI-4B, base vectorRLI-4B
Biology41.942.652.763.172.873.579.681.5
Earth Sci.49.152.258.664.772.174.678.080.0
Economics40.234.946.053.661.966.067.371.3
Psychology30.635.646.650.159.965.564.369.3
Robotics39.240.948.449.256.764.764.467.9
Stack Ov.40.245.752.852.763.867.768.171.0
Sus. Liv.40.735.141.053.958.863.866.468.8
Avg.40.341.049.555.363.768.069.772.8

RLI-4B is the best retriever on all 7 domains, ahead of 8B models, and the reads add +3.1 over its already strong base vector. In nDCG@10 the gain holds on all 7 domains, both for the submitted model (vs. its base vector, official code) and on the second mixture (vs. a same-recipe no-reads model, MTEB version):

DomainSubmitted: base vectorSubmitted: RLIΔ2nd mixture: no reads2nd mixture: RLIΔ
Biology73.376.6+3.372.076.2+4.2
Earth Sci.72.074.8+2.871.273.6+2.3
Economics59.364.0+4.860.064.1+4.1
Psychology57.462.7+5.360.164.8+4.7
Robotics55.859.6+3.858.860.5+1.7
Stack Ov.63.367.4+4.061.969.4+7.5
Sus. Liv.59.963.1+3.259.161.5+2.4
Avg.63.066.9+3.963.367.2+3.8

Comment 4 of 4

W2 / Q2: results beyond BRIGHT (2/2): TEMPO

TEMPO (temporal reasoning retrieval, 13 domains, 1,730 queries, nDCG@10), no TEMPO training data:

DomainBM25GritLM-7BReasonIR-8BRaDeR-7BSFR-MistralE5-Mistral-7BRLI-4B, base vectorRLI-4B
Bitcoin6.219.116.314.917.616.313.410.8
Cardano13.421.722.918.628.135.722.729.4
IOTA9.736.641.719.237.141.729.437.2
Monero2.814.719.621.023.720.018.213.9
Economics5.817.220.022.721.925.027.434.1
Law12.738.337.933.540.834.034.227.7
Politics32.741.435.432.444.947.947.455.3
History9.227.334.325.832.428.735.037.2
Quant2.521.619.527.816.813.815.814.9
Travel4.625.021.426.129.728.320.816.2
Workplace6.230.830.036.631.632.935.545.7
Genealogy13.326.930.318.731.733.530.034.0
HSM21.233.424.716.933.537.727.536.8
Avg.10.827.227.224.230.030.427.530.2

The reads add +2.8 over the base vector and improve 8 of 13 domains.

Non-reasoning retrieval (Q2). RLI targets reasoning-intensive retrieval, where a document must match the query on several points; we do not claim gains on mostly topical data such as BEIR. There is a simple fallback: all stored vectors have the same norm, so setting the query's read block to zero ranks documents exactly by the base embedding, from the same index and with no re-encoding. The reads can thus be switched off per collection.

We will add all these tables to the appendix.

Dear Reviewer,

we hope you have a chance to check our response above. Please let us know if you need any further clarification or another experiment before the deadline

thank you!

AuthorsOpenReview ↗

Gentle Reminder Before Tomorrow's Deadline (Nov 18)

Dear Reviewer Jy6h,

With the discussion deadline tomorrow (November 18), we hope you might have a brief moment to review our response above.

Please let us know if we can clarify anything further before the discussion period ends.

Thank you for your time!

Comments on the paper

1 comment

Dear reviewers, The authors' rebuttal has been posted. Can you take a look at the authors' responses to see whether your concerns have been addressed? Thanks!

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.