acceptodds
Under review as a conference paper at ICLR 2027

Follow the Entities: A Corpus Map for Agentic Search

Abstract

Answering questions and completing tasks over large document collections often requires connecting evidence spread across multiple documents, such as a project's approval recorded in one, its requirements in another, and its latest status in a third. Recent LLM agents approach this by iteratively searching the full corpus rather than reading only a fixed set of top-ranked documents. However, when the corpus is exposed only as a flat collection of files, a relevant document gives no indication of how it relates to others, so the agent must rediscover these relationships for every query, often missing complementary evidence while simultaneously consuming substantial additional tokens. To address this, we introduce CorpusMap, a navigation layer that organizes the corpus around its recurring entities, which are identifiable from the documents themselves and can link a single document to many others across sources. Specifically, CorpusMap represents each recurring entity as an Entity Page that aggregates information about it and links to every document that refers to it, forming a graph between entities and documents that the agent can traverse to gather otherwise disconnected evidence. Moreover, since CorpusMap is constructed offline by resolving mentions of the same entity across documents, its links are shared across queries rather than rediscovered repeatedly at inference time. Using 7 different models with 3 benchmark datasets, we show that CorpusMap improves both evidence discovery and answer quality over raw-corpus agentic search while using fewer tokens on average, and further outperforms 4 alternative navigation layers, suggesting that entities serve as effective anchors for navigating large document collections.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
Agentic Retrieval, LLM Agents, Corpus Navigation

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_iZj1OpenReview ↗
Rating
3
Confidence
4
Informativeness
3
Presentation
3
Soundness
3(+1)
Read review
Paper summary

The paper proposes CorpusMap, a new entity-based indexing system for agentic retrieval. CorpusMap recognizes and resolves the named entities in documents to create entity pages, and uses the entity pages as input to LLM agents for navigation. On EnterpriseRAG-Bench, WixQA and HERB, the method achieve better results than baselines in most cases. Practical aspects e.g. cost to build the index, and reusing the map over different LLMs and incremental updates are also discussed.

Critical strengths
  1. The paper is clearly defined, easy to understand, and concise in construction. I think this is an important contribution to advancing enterprise agentic search, and a cheaper yet potentially more effective solution than the well-used GraphRAG.
  2. Experiments are generally well conducted, with cost reporting, discussion of practical aspects, and quite decent backbone coverage. I agree the method would work in many cases, with some limitations on the dataset coverage; please see weaknesses below.
Critical weaknesses

I am not very satisfied with the scale of the experiments in terms of the number of queries, documents, and diversity of datasets. Did you try to cover diverse types of datasets, i.e., weakly linked documents, entity-dense documents, table-heavy ones, etc. And a scalability test for more documents would also strengthen the efficiency experiments. I am worried that as the number of documents scales up, the accuracy/noise in the NER step would degrade the downstream performance. Besides, according to the results in Table 8, having the entity-linked docs is almost the same performance as the full method, so some discussion on in which cases we need to walk on the map vs. when we only need to retrieve based on entities would be helpful.

Questions for authors

Please see weaknesses. Additionally, please also report the performance of name entity resolution if that is feasible.

6 comments
AuthorsOpenReview ↗

Response to Reviewer iZj1 (1/2)

We thank you very much for your careful and constructive review. We are also grateful that you recognized CorpusMap as a new entity-based approach to agentic retrieval and an important contribution to advancing enterprise agentic search with a more effective solution at a lower cost, and that you found our method clear and concise and our experiments well conducted, including the cost analysis, practical considerations such as map reuse and incremental updates, and the coverage of multiple LLMs. Below, we respond to each of your comments, including new results on additional benchmarks and larger corpora.


Weaknesses 1) I am not very satisfied with the scale of the experiments in terms of the number of queries, documents, and diversity of datasets. Did you try to cover diverse types of datasets, i.e., weakly linked documents, entity-dense documents, table-heavy ones, etc.

We thank you for this insightful comment, and we fully agree that the diversity of datasets is important, which is why we chose three benchmarks that include both entity-dense and weakly linked documents, while covering diverse types of documents, from issue tickets, wiki pages, and pull requests across nine workplace applications (EnterpriseRAG-Bench) and help-center articles (WixQA) to chat messages and meeting transcripts (HERB). For instance, EnterpriseRAG-Bench is entity-dense, with 24.7 Entity Pages linked to each document on average, whereas WixQA is weakly linked, as the articles needed for the same question typically share only broad entities, such as a product mentioned in many other articles. As shown in Table 1 and summarized in Table C.1, CorpusMap improves over Raw Corpus on all three benchmarks.

In addition, to further address your concern, we evaluate CorpusMap on three more benchmarks of different types, namely entity-dense news articles (MultiHop-RAG [C1]), table-heavy financial reports (ViDoRe V3 Finance-EN [C2]), and documents with renamed entities (SynthWorlds-SM [C3]). As shown in Table C.1, CorpusMap outperforms Raw Corpus on every metric of all three additional benchmarks while using fewer tokens. Regarding scale, these benchmarks include up to 2,255 questions, and we further scale the corpus up to 100k documents, as detailed in our response to Weaknesses 2.1. We thank you again for this valuable comment. We will include these results in the updated paper.

Table C.1: Performance on our three benchmarks and three additional benchmarks

DatasetMetricRaw CorpusCorpusMap (Ours)Tokens
EnterpriseRAG-BenchDoc. Rec.56.4075.110.74×
Correct.60.4267.08
Complete.73.1277.42
WixQACtx. Rec.47.3676.900.32×
Fact.59.3969.30
HERBContent44.8650.451.16×
MultiHop-RAGDoc. Rec.6.8132.770.58×
Accuracy77.1280.00
ViDoRe V3 Finance-ENPage recall20.6831.040.41×
nDCG@1030.5642.25
Correct answers60.0963.95
SynthWorlds-SMDoc. Rec.17.1742.810.84×
EM57.9259.67
F159.5761.74

[C1] MultiHop-RAG: Benchmarking Retrieval-Augmented Generation for Multi-Hop Queries

[C2] ViDoRe V3: A Comprehensive Evaluation of Retrieval Augmented Generation in Complex Real-World Scenarios

[C3] SynthWorlds: Controlled Parallel Worlds for Disentangling Reasoning and Knowledge in Language Models

AuthorsOpenReview ↗

Response to Reviewer iZj1 (2/2)

Weaknesses 2.1) A scalability test for more documents would also strengthen the efficiency experiments.

We also consider scalability important, which is why we examined CorpusMap with GLinker as the corpus grows in Figure 4, where it outperforms Raw Corpus on every metric from 2.8k to 20k documents. Nevertheless, following your suggestion, we further scale the corpus to 50k and 100k documents. As shown in Table C.2, CorpusMap with GLinker still outperforms Raw Corpus on every metric at both sizes while using fewer tokens. Thank you again for this helpful suggestion!

Table C.2: Performance on larger corpora of EnterpriseRAG-Bench

DocumentsMethodDoc. Rec.Correct.Complete.Tokens
50kRaw Corpus43.7041.2563.55110.7k
50kCorpusMap with GLinker (Ours)60.7265.0074.5070.7k
100kRaw Corpus42.5445.0057.94134.4k
100kCorpusMap with GLinker (Ours)62.5957.5070.1871.7k

Weaknesses 2.2) I am worried that as the number of documents scales up, the accuracy/noise in the NER step would degrade the downstream performance.

We thank you for raising this important concern. Entity recognition (NER) in CorpusMap does not depend on the number of documents, as it recognizes the mentions of each document from that document alone, without referring to other documents. For instance, since our larger corpora are built by adding documents to the 2,819 documents of EnterpriseRAG-Bench, we compare the mentions recognized in these 2,819 documents across corpus sizes, and they are the same from 2.8k to 100k documents. However, we agree that linking these mentions to the same entity across documents (entity resolution) can become more challenging as the corpus grows, since more entities with similar names appear, which may introduce noise into the map. For example, measured on the employees of EnterpriseRAG-Bench, whose ground-truth identities are available, the precision of linking their mentions is 0.989 at 2.8k and 0.987 at 100k documents, while its recall among the linked mentions decreases from 0.957 to 0.912. Nevertheless, entity recognition and linking are intermediate steps for building the map that the agent uses, and CorpusMap continues to outperform Raw Corpus on every metric at 50k and 100k documents (Table C.2), as discussed in our response to Weaknesses 2.1. We will include the evaluation of linking on larger corpora in the updated paper.


Weaknesses 3) According to the results in Table 8, having the entity-linked docs is almost the same performance as the full method, so some discussion on in which cases we need to walk on the map vs. when we only need to retrieve based on entities would be helpful.

We would like to clarify that the setting with the entity-linked documents that you mentioned is exactly our full method, in which the agent receives these documents as its initial candidates while having access to the full map (Section 3.4 and Appendix B.3). Table 8 compares variants of CorpusMap that differ only in the candidates given to the agent, namely none, Entity Pages, entity-linked documents, or both, and giving both is one of these variants rather than the full method. We chose the entity-linked documents as the default for their efficiency, as they achieve comparable quality with the fewest tokens (Table 8). Specifically, with Entity Pages as candidates, the agent reads these pages in addition to the documents they link, whereas with the linked documents, it opens these documents right away and can still explore the map from them when needed. For instance, Table 10 shows a case where the agent needs to walk on the map, in which it reads a draft of a manifest and then reaches its v1 specification, stored in a different application, through the Entity Page of Serving Runtime.


Question 1) Additionally, please also report the performance of name entity resolution if that is feasible.

We sincerely thank you for this suggestion. Accordingly, we evaluate the entity resolution of CorpusMap on the employees of HERB, whose ground-truth identities are available. Specifically, we check whether the map links every document that mentions an employee to the Entity Page of that employee, without mixing different employees in one page. CorpusMap achieves a B³ F1 of 0.976, a standard metric of cross-document coreference [C4], with precision 0.999 and recall 0.954. In addition, we discuss how entity resolution changes as the corpus grows in our response to Weaknesses 2.2. We will include this evaluation in the updated paper.

[C4] Algorithms for Scoring Coreference Chains

Thank you for the additional experiments and clarifications. I now understand that the entity-linked document setting in Table 8 retains full map access.

My remaining question is whether online map navigation provides additional benefits beyond entity-based candidate retrieval. Could you compare the same entity-derived candidate list with versus without subsequent access to the map, keeping the agent, raw-document search tools, and budget fixed? This would help isolate the contribution of navigation and clarify when it is useful.

After considering the other reviewer’s concerns about novelty, I still see a meaningful contribution in the proposed design and empirical results, and I maintain my weak acceptance rating. However, I encourage the authors to narrow the novelty claims and more precisely position the work relative to GraphReader and HippoRAG 2, acknowledging the existing ideas while emphasizing the specific design choices and benefits demonstrated here.

Overall, I remain supportive of this paper.

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

CorpusMap first builds an entity and document map for the corpus offline. In this process, it extracts entities from each document, merges the same entity across documents, and writes an Entity Page for every entity that appears in at least two documents. At query time, a search agent navigates both the raw documents and the entity pages using shell commands. The paper also shows that combining the entity pages and BM25 gives really good results. On three different RAG benchmarks, CorpusMap improves answer quality over directly searching the raw corpus by 6.4–11.7 points across four models, while using 34–57% fewer input tokens per query, and outperforms four other methods.

Critical strengths

The paper studies an important and real problem.

Critical weaknesses

The work seems incremental and has limited novelty. Organizing documents around entities, with entity pages linking back to their source documents, is a well-explored idea in entity-centric and graph-based retrieval (e.g., GraphRAG, Edge et al., 2024; HippoRAG, Gutiérrez et al., 2024; LightRAG, Guo et al., 2024), and the entity extraction and resolution steps in this paper also use existing methods. I feel like the paper is mainly a combination of existing methods rather than a clear new contribution.

One new part I find in this paper is letting an agent browse the entity pages, but GraphReader (Li et al., 2024) already does a similar thing that lets an agent explore an offline entity graph. Also, in the experiments, I didn’t find clear evidence that this helps. Without the BM25 candidate list, CorpusMap scores only 3.4 points higher than raw search and uses about 2.4× more tokens, so it seems that most of the gain comes from the candidate list. In addition, HippoRAG and GraphRAG are only compared as retrieve-then-generate baselines (Table 3), and GraphReader and LightRAG are not compared at all. The paper should use the same agent and give it access to these methods to do a fairer comparison.

Overall, the problem is important, but I find the contribution minor and the novelty insufficient.

Questions for authors

see weakness

5 comments
AuthorsOpenReview ↗

Response to Reviewer yB25 (1/2)

We thank you for your review and for recognizing that the problem we study is important and real. We have made every effort to address each of your concerns thoroughly, including new experiments that compare CorpusMap with GraphRAG, HippoRAG, LightRAG, and GraphReader in our setting, as you suggested.


Weaknesses 1) The work seems incremental and has limited novelty. Organizing documents around entities, with entity pages linking back to their source documents, is a well-explored idea in entity-centric and graph-based retrieval (e.g., GraphRAG, Edge et al., 2024; HippoRAG, Gutiérrez et al., 2024; LightRAG, Guo et al., 2024), and the entity extraction and resolution steps in this paper also use existing methods. I feel like the paper is mainly a combination of existing methods rather than a clear new contribution.

We appreciate your concern. While organizing documents around entities has been explored in graph-based retrieval, we would like to emphasize that our key insight is that, once an agent can read full documents, the document itself can serve as the relation. Prior methods, such as GraphRAG, HippoRAG, and LightRAG, organize a corpus around relation triples (e1,r,e2)(e_1, r, e_2) extracted between entities, such as (Jane, approved, Project Atlas). In contrast, CorpusMap connects entities through the documents that mention them rather than through relations extracted between pairs of entities, such as Jane and Project Atlas through the email recording the approval, so that the agent can read how they relate. This brings two advantages. First, a relation triple in prior methods keeps only a relation between two entities within a short chunk, losing the context around it, whereas a document in CorpusMap keeps all the entities it mentions within their full context, letting the agent recover relationships among any number of them by reading the text. Second, prior methods link the same entity across chunks by its name alone, through exact string matching in GraphRAG and LightRAG or phrase embeddings in HippoRAG, whereas CorpusMap resolves each entity using the full context of each file. In fact, adding relation edges to CorpusMap barely changes document recall while increasing input tokens (Appendix B.4), indicating that a separate relation graph becomes redundant once the agent reads documents.

Nevertheless, following your suggestion, we further compare CorpusMap with these methods under the same agent, by giving the agent the retrieval of each method as an additional search command, as detailed in our response to Weaknesses 2.3. As shown in Table B.1, CorpusMap outperforms all three on every metric while using the fewest tokens, indicating that a map linking entities to the documents the agent reads helps it more than relation graphs used inside a retriever.

Table B.1: Comparison with graph-based methods under the same agent on EnterpriseRAG-Bench

MethodDoc. Rec.Correct.Complete.Tokens
Agent (Raw Corpus)56.4060.4273.1280.7k
Agent + HippoRAG61.6662.5074.1069.7k
Agent + GraphRAG53.1457.5071.5178.8k
Agent + LightRAG58.4561.2574.7493.4k
Agent + CorpusMap (Ours)75.1167.0877.4260.1k
AuthorsOpenReview ↗

Response to Reviewer yB25 (2/2)

Weaknesses 2.1) One new part I find in this paper is letting an agent browse the entity pages, but GraphReader (Li et al., 2024) already does a similar thing that lets an agent explore an offline entity graph.

We thank you for recognizing that letting an agent browse the Entity Pages is a new part of our work. However, we would like to clarify that CorpusMap differs from GraphReader, as GraphReader addresses a fundamentally different task, long-context question answering, in which a single long text of 16k to 256k tokens is given with the question. Its graph is a way for an LLM with a 4k-token context window to read that given text piece by piece. In contrast, CorpusMap targets search over a corpus made up of a very large number of documents, where the agent must first find where to look by itself, as these documents together are far too large to be given as a single long context (about 6 million tokens in EnterpriseRAG-Bench, about 30 million tokens in Figure 4, and over 100 million tokens when scaled to 100k documents), and real enterprise corpora can grow even larger.

Nevertheless, following your suggestion, we reimplement GraphReader with its original prompts and the same LLM as CorpusMap, building its graph from all documents chunk by chunk, in the same way as for a long text. Designed to read a given text rather than to search a corpus, GraphReader first shows its agent every node of the graph to choose where to start, which is impossible for our corpus, whose graph has about 190k nodes. We therefore show it only the nodes most similar to the question that fit in its context window. As shown in Table B.2, CorpusMap substantially outperforms GraphReader. We will include this comparison in the updated paper.

Table B.2: Performance of GraphReader on EnterpriseRAG-Bench

MethodCorrect.Complete.
Raw Corpus60.4273.12
GraphReader43.7552.76
CorpusMap (Ours)67.0877.42

Weaknesses 2.2) Without the BM25 candidate list, CorpusMap scores only 3.4 points higher than raw search and uses about 2.4× more tokens, so it seems that most of the gain comes from the candidate list.

We would like to clarify that the gain of CorpusMap does not come from the candidate list alone, as CorpusMap consists of both the Entity Pages and the candidate list drawn from them (Section 3.4), which together help the agent (the candidates by pointing it to where to start and the Entity Pages by guiding its navigation from there). Specifically, the candidates are the documents linked to the Entity Pages relevant to the question, so that the agent starts from the region of the corpus around these entities. As shown in Table 8, giving Raw Corpus a candidate list without the map only marginally improves its quality, and, as you also noted, the map without candidates improves over Raw Corpus but spends more tokens exploring, whereas combining the two, as CorpusMap does, achieves much higher quality with fewer tokens.


Weaknesses 2.3) In addition, HippoRAG and GraphRAG are only compared as retrieve-then-generate baselines (Table 3), and GraphReader and LightRAG are not compared at all. The paper should use the same agent and give it access to these methods to do a fairer comparison.

While Table 3 compares HippoRAG and GraphRAG in their original retrieve-then-generate setting, following your suggestion, we further compare them, together with LightRAG, with CorpusMap under the same agent, as discussed in our response to Weaknesses 1. Specifically, we give the agent, without the map, one additional command per method, hipporag_search, graphrag_search, or lightrag_search, which runs the method's own retrieval with its default settings on a query written by the agent and returns the documents and context that the method would pass to its generator. The agent keeps its tools and the same budget. As shown in Table B.1, CorpusMap outperforms all three on every metric while using the fewest tokens.

Regarding GraphReader, as detailed in our response to Weaknesses 2.1, it addresses a fundamentally different task, and even when it is run in our setting, CorpusMap substantially outperforms it (Table B.2). We will include these results in the updated paper. We hope that these clarifications are helpful when assessing the merit of our work, and we thank you again for your time.

Dear Reviewer yB25,

As the discussion period ends in less than a day, we would like to gently remind you of our responses and the revised paper, in which CorpusMap outperforms HippoRAG, GraphRAG, LightRAG, and GraphReader on every metric in our setting (Tables 4 and 5), while the candidate list alone only marginally improves over Raw Corpus (Table 10). Your review led to substantial improvements to our work, including these comparisons and a rewritten related work that clarifies how CorpusMap differs from each of these methods. We would be deeply grateful if you could kindly take a moment to review them, and if they have addressed your concerns, we would sincerely appreciate it if you could consider reflecting this in your evaluation. Thank you once again for your time and thoughtful feedback, which truly means a lot to us.

Warm regards, Authors

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

This paper proposes CorpusMap, which organizes a document collection around recurring entities such as people, projects, and products. It builds Entity Pages offline, collecting facts with source references and linking documents that mention the same entity. An agent can then follow these links to find evidence across documents rather than repeatedly discovering the connections through search. Experiments on three benchmarks show better evidence retrieval and answer quality with fewer query-time tokens. The paper also examines map reuse across models and incremental updates.

Critical strengths
  1. I find organizing the corpus around shared entities interesting. These connections can be reused across questions, instead of asking the agent to discover them again each time.
  2. The experiments show improvements in answer quality while reducing query-time tokens. The writing is also clear and easy to follow.
Critical weaknesses

The map construction cost is still a concern for me. Table 4 reports costs up to around $4,700 for only 2,819 documents. The Luna results and the GLinker alternative are encouraging, but I would like to understand the full cost of the cheaper options better. Whether this is practical depends on how often the corpus is queried and updated.

Questions for authors

What is the construction cost per 1,000 documents for the GLinker version, including compute cost and runtime? How much quality is lost compared with the LLM-built map? For me, keeping the gains with a much cheaper construction process would make the work more useful in practice.

2 comments
AuthorsOpenReview ↗

Response to Reviewer fqZf

We sincerely thank you for your thoughtful and encouraging review. We are also grateful that you found our idea of linking documents through their shared entities, once for all questions, interesting, and that you recognized our results, which improve answer quality while reducing the tokens used per query, and found our paper easy to follow. We have carefully considered all of your comments and suggestions, and provide point-by-point responses below.


Weaknesses 1) The map construction cost is still a concern for me. The Luna results and the GLinker alternative are encouraging, but I would like to understand the full cost of the cheaper options better. Whether this is practical depends on how often the corpus is queried and updated.

Thank you for raising this important point. We fully agree that the construction cost is important, and in fact, this is why we examined the map built by Luna and the GLinker alternative in our experiments. As you also noted, both keep the construction cost small while remaining effective, as shown in Table 4, which reports the construction cost and quality of maps built by different LLMs, and Figure 4, which compares the GLinker map with the LLM-built map across corpus sizes. Specifically, the map built by Luna costs USD 26.48 per 1,000 documents, the least among the LLM-built maps in Table 4, while its quality is close to that of the maps built by GPT-5.5 and Sol with the same answering LLM, at a small fraction of their cost. CorpusMap with GLinker builds the map without any LLM or API call, using BERT-based models of 82M to 307M parameters that are light enough to run on a single local GPU. For instance, on a single RTX 2080 Ti GPU with 11GB of memory, it takes only about 30 minutes per 1,000 documents, which costs about USD 0.14 even when renting a comparable GPU in the cloud (USD 0.27 per hour for an RTX A5000 on RunPod). Nevertheless, it remains comparably effective to the LLM-built map, as shown by the filled blue circles (CorpusMap with GLinker) against the purple stars (CorpusMap with LLM) in Figure 4, and it still outperforms Raw Corpus on every metric at every corpus size.

Regarding how often the corpus is queried and updated, our paper already reports both, the cost per query with the construction cost amortized in Figure 5 and incremental map updates in Figure 3. Specifically, Figure 5 shows that the construction cost of the maps built with frontier LLMs is recovered after about 9K to 26K queries, depending on the LLM, which an organization of 1,000 employees, each asking a few questions per day, would reach within about one to two weeks, whereas, as noted above, the map built with GLinker costs almost nothing on a local GPU, leaving little cost to recover. In addition, Figure 3 shows that the map can be updated incrementally as new documents arrive, with each update using only 29% to 66% of the tokens of a full rebuild while reaching comparable quality.


Question 1) What is the construction cost per 1,000 documents for the GLinker version, including compute cost and runtime?

As discussed in our response to Weaknesses 1, CorpusMap with GLinker uses BERT-based models light enough to run on a single local GPU. On a single RTX 2080 Ti with 11GB of memory, it takes about 30 minutes per 1,000 documents, which costs only about USD 0.14 (assuming a cloud rental rate of USD 0.27 per hour for a comparable GPU).


Question 2) How much quality is lost compared with the LLM-built map? For me, keeping the gains with a much cheaper construction process would make the work more useful in practice.

As detailed in our response to Weaknesses 1, the quality lost is small, as shown in Figure 4, which compares the GLinker map with the LLM-built map across corpus sizes. On average over corpus sizes ranging from 2.8k to 20k documents, CorpusMap with GLinker retains about 95% of the retrieval and answer quality of CorpusMap with LLM, while still improving over Raw Corpus on every metric.

Dear Reviewer fqZf,

As the discussion period ends in less than a day, we would like to gently remind you of our responses and the revised paper, which show that CorpusMap can also be built at a much lower cost with GLinker (which requires no LLM calls), while remaining nearly as effective as the LLM-built map and outperforming Raw Corpus even on corpora of up to 100k documents. Your questions led us to quantify the full cost of this cheaper construction and the quality that it retains. We would be deeply grateful if you could kindly take a moment to review them, and if they have addressed your concern, we would sincerely appreciate it if you could consider reflecting this in your evaluation. Thank you once again for your time and thoughtful feedback, which truly means a lot to us.

Warm regards, Authors

Comments on the paper

1 comment
AuthorsOpenReview ↗

To All Reviewers: Revised Paper Uploaded

We sincerely thank all reviewers for their thoughtful and constructive comments, which have been greatly helpful in improving our paper. We would like to let you know that we have updated our paper to address all of these comments, with every change marked in blue. We fully understand that your time is valuable, and we would be deeply grateful if you could kindly take a moment to review our responses and the revised paper. If you have any further questions, we would be happy to address them!

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.