Papers for

search engine developers

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Compact multilingual retrievers match larger models for European languages

Parameter-Efficient Retrievers for Polish and European Languages

Abstract: Dense retrieval systems increasingly rely on multi-billion-parameter language models, whose memory and computational requirements make large-scale indexing, frequent corpus updates, and low-latency serving costly. We present a three-stage training pipeline for developing compact and efficient retrievers that remain competitive with substantially larger models. The pipeline combines cross-lingual alignment, relational knowledge distillation, and contrastive fine-tuning. It requires no original ground-truth relevance labels, relying exclusively on supervision generated by strong embedding models and rerankers utilised as teachers. Using this pipeline, we develop PolDense and EuroDense, both supporting contexts of up to 8,192 tokens. PolDense is a family of six Polish retrievers ranging from 17M to 1B parameters. EuroDense is a 435M-parameter retriever supporting nine European languages. We conduct an extensive evaluation covering 41 Polish and 150 multilingual retrieval tasks. The results demonstrate strong quality-efficiency trade-offs. PolDense-1B outperforms the evaluated retrievers with up to 9B parameters, while the PolDense family forms the Pareto frontier across model sizes. Among the evaluated models below 1B parameters, EuroDense ranks first in both task-averaged and language-averaged performance and leads in seven of nine languages. We release all models publicly.

Fri 11 SeptComputation and Language
The gist
Large language models help computers find relevant documents but are very big and slow, making them hard to use frequently or for many languages. This paper shows a new way to train smaller, faster search tools that work almost as well as the biggest ones, especially for Polish and other European languages. The authors used clever training techniques that don’t need lots of labeled examples but learn from existing strong models. They made several versions, some very small and some larger, and tested them widely, finding these compact models often do better than much bigger ones.
Open 2609.12913v1

Multilingual dataset helps detect russian propaganda in search results

SWARM: A Multilingual Human-Annotated Dataset for Russian Propaganda Detection in Search Engine Results

Abstract: Russian state propaganda spreads across many languages and online spaces. Yet, most computational work examines only one such space, usually social media, in one or two languages, and analyses sources rather than content. We introduce SWARM (Search-Web documents Annotated for Russian propaganda, Multilingual), a dataset of 2,183 search engine results across nine languages and diverse web domains (e.g., news, blogs, government sites), each annotated by trained coders for whether it supports a recurring Russian propaganda narrative. We benchmark a source-based blocklist, supervised classifiers, and zero-shot LLMs against these labels. The blocklist misses most propaganda-supporting documents, because such content is not confined to flagged "propaganda" outlets but also appears on mainstream ones. Content-level analysis helps, though how much depends on the model: the strongest LLM reaches a positive-class F1 of 0.73, whereas the supervised classifiers reach only about 0.5, with the smaller LLMs over-predicting support, mistaking topical relevance for endorsement. Detecting search-borne propaganda thus requires per-language, content-level evaluation, which we hope SWARM and our evaluation code enable.

Fri 11 SeptComputation and Language
The gist
Russian propaganda appears in many languages and on various websites, not just on known propaganda sources. The authors created SWARM, a dataset of search engine results in nine languages, each marked by experts for Russian propaganda content. They tested different ways to detect such propaganda and found that analyzing the content itself works better than just blocking certain sources. However, success depends on the model used, with some mistakes caused by confusing the topic of a page with support for propaganda.
Open 2609.12653v1

Atlas proves graph-based semantic search results quickly and privately

Atlas: Efficient Verifiable Semantic Search

Abstract: Semantic search is a core primitive of modern applications, powering recommender systems, web search, and retrieval-augmented generation for language models. The provider controls the index and query execution, leaving clients to trust that results come from the right algorithm over the intended index. A provider may truncate search to cut cost, bias results, or otherwise deviate from the specified execution undetected. Verifiability can remove this trust assumption by proving that results follow the agreed algorithm over a committed index. Realizing this efficiently is hard, as retrieval at scale relies on HNSW, a graph-based algorithm whose data-dependent traversal maps poorly onto the fixed constraint systems of zero-knowledge proofs. Prior verifiable systems therefore target regular, cluster-based indices that are easier to encode, sacrificing the recall of graph-based search. We present Atlas, a system that lets a provider prove a query was answered correctly against its committed index without revealing the index. At its core is a new zero-knowledge proof for HNSW search, built on three techniques: preprocessing that shifts all database-dependent cost offline, so per-query proving scales with the traversal rather than the database; a restructuring of HNSW into a fixed-size-state procedure that we prove returns the same result; and a timestep-tagged batching that merges the per-step arguments of the entire traversal into one. Atlas is the first to demonstrate verifiable graph-based search at scale, proving a query in under a second on the SIFT1M benchmark and in 2.0 seconds at 100 million vectors, while maintaining the recall of plaintext HNSW and revealing nothing about the index beyond the result. In a complete RAG pipeline, Atlas' proven retrieval preserves end-to-end answer quality, and reaches higher quality at lower proving cost than all prior verifiable retrieval systems.

Thu 10 SeptCryptography and Security
The gist
Semantic search helps computers find results based on meaning, but usually you must trust the search provider to be honest about how they found answers. The authors created Atlas, a system that lets providers prove they did the search correctly without revealing their data. Atlas uses clever math to make these proofs fast, even on huge datasets, while keeping search quality the same. This can help users trust recommendations or search results without giving up privacy or performance.
Open 2609.11841v1

Low-bit quantization accuracy depends on exact margin distributions

When Does Low-Bit Quantization Preserve the Decisions of Vector Search?

Abstract: Low-bit quantization can achieve high recall on some vector representations and fail sharply on others, while average distortion and global rank correlation do not explain the difference. We study quantized vector search at the level of the comparisons consumed by ranking and graph-pruning algorithms. Our first result is a distribution-free decomposition: the probability that a comparison flips is bounded by the probability mass of exact margins near zero plus the tail probability of the calibrated residual. We then account for dependence between residuals that share a query or graph node, and derive covariance-aware second-moment identities and tail bounds under a joint MGF proxy. For a frozen candidate permutation, we prove a deterministic coupling theorem for Vamana neighbour selection: the approximate replay returns the exact neighbour list exactly when all candidate-level pruning actions agree on the frozen exact states. We connect these results to representation geometry through an exact Gaussian oracle, establish a strict correlation gain from a deterministic magnitude bit in an aligned bilinear model, and give a rare-contamination construction showing why marginal Gaussian diagnostics do not imply the required residual tails. When analytical assumptions are unavailable, a held-out block certificate bounds the selective failure risk of a frozen quantized rule. Across learned, classical, and synthetic embeddings, standardized exact margins predict held-out ranking and pruning flip rates substantially better than global rank correlation. The framework applies to coordinate binary codes, RaBitQ, Lucene BBQ, and product quantizers through a common decision interface.

Wed 9 SeptDatabasesInformation RetrievalMachine Learning
The gist
Low-bit quantization is a way to make searching large sets of vectors faster by using fewer bits per number. The authors found that average distortion and overall ranking similarity don’t fully explain why quantization works well sometimes and fails badly other times. They developed new mathematical tools to understand when decisions in vector search stay the same after quantization, focusing on how small differences between vectors and their neighbors affect errors. Their framework helps predict when quantization will keep the right search order by looking at exact margins rather than just rough rank correlations.
Open 2609.09854v1

Tone changes how AI judges relevance in search results

Should I Be Polite to My LLM Relevance Judge? Tone as a Severity Operating-Point Shift

Abstract: Large language models are increasingly used as relevance judges, yet their labels can shift with prompt surface form. We study one such feature -- tone -- on 3,498 TREC DL19/DL20 query-passage pairs, across eight judge models, five classifier-calibrated politeness levels, and three paraphrases per level. Effects are strongly model-dependent: one judge shows a structured U-shaped response, whereas most show only small changes. Where tone changes agreement, the results are more consistent with a shift in the judge's severity operating point -- its overall scoring leniency -- than with improved judgment. Agreement rises or falls as this shift moves the judge toward or away from human annotators' strictness. A query-disjoint cross-fit retains the expected association (Spearman $ρ= -0.683$; exact model-block permutation $p = 0.019$). Tone affects calibration-based agreement more than ranking outcomes: across 32 model-tone contrasts, the largest absolute mean change in NDCG@10 is 0.011, although Kendall's $τ$ as low as 0.743 shows that reordering is reduced, not absent. The account reconciles prior contradictory findings and identifies prompt tone as a potential validity threat when absolute relevance labels matter.

Wed 9 SeptInformation Retrieval
The gist
Some large language models judge how well search results match a query, but their decisions can change based on how the prompt is worded—especially the tone used. The authors studied different politeness levels and found that changes in tone mostly shift how strict or lenient the model is, rather than making it better or worse at judging relevance. This means being polite or not can make the model act more or less harsh, affecting agreement with human judgments. These findings explain past mixed results and warn that tone can affect the trustworthiness of relevance labels from AI judges.
Open 2609.09703v1

Q2D-Web builds large benchmark to test web search for AI agents

Q2D-Web: A Large-Scale Benchmark for Retrieval in Agentic RAG Systems

Abstract: Evaluating first-stage retrievers in large-scale production RAG requires a benchmark that pairs a large-scale corpus with a large set of agent-reformulated search queries based on real user queries and their conversation threads, and that labels many relevant documents per query. No existing public benchmark evaluates this setting: large-scale collections typically provide only a small number of evaluation queries, whereas benchmarks with many queries generally contain only millions of documents. Moreover, most benchmarks assess human-written queries, while the first-stage retrievers in agentic RAG pipelines serve machine-written reformulations whose distribution differs from human search behavior. To overcome these evaluation gaps, we introduce Q2D-Web (Query2Doc-Web), a large-scale agentic retrieval benchmark consisting of a 190M-document web corpus and 70k agentic search queries in ten languages, reformulated from real-world user queries in production systems. Q2D-Web provides three sets of fixed relevance judgments: agent citations, production rankings, and a combined set that unions both signals and adds LLM-based judgments of unlabeled pooled documents to reduce false negatives. We benchmark 13 retrievers including lexical, dense, and late-interaction models and find that their relative ordering is largely insensitive to the choice of judgment set, while diverging substantially across topical domains, query languages, and query types. To enable fast evaluation, we also study subcorpus sampling as an approximation to full-corpus evaluations. Retaining a third of the corpus, selected by reciprocal rank fusion over pooled retriever runs, preserves the full-corpus model ranking under the combined judgments while raising absolute Recall@1000 only by 3 to 7 points. The public leaderboard is accessible under: https://huggingface.co/spaces/perplexity-ai/q2d-web-leaderboard

Tue 8 SeptInformation RetrievalComputation and Language
The gist
Finding good information in huge collections of web pages is hard to test properly. The authors created Q2D-Web, a very large set of web pages combined with tens of thousands of AI-adapted search queries based on real user questions. This lets them check how well different search methods work when AI agents rewrite queries before searching. They also provide different ways to judge which documents are relevant and show that some search methods work better depending on language and topic. They tested ways to speed up evaluation by using smaller parts of the data without losing accuracy.
Open 2609.08887v1

Open source tool improves consistency and results in document retrieval

REDSI: Addressing the Reproducibility and Evaluation Consistency of Differentiable Search Indexing for Document Retrieval

Abstract: The differentiable search index (DSI) framework (Tay et al., 2022) has become the de facto baseline for generative retrieval. However, DSI is hard to reproduce: no public implementation covers all three original document identifier types (atomic, naive, semantic), reported results vary widely, and the ubiquitous NQ320K dataset is built from Natural Questions through diverse and underspecified preprocessing. We introduce ReDSI, the first open-source DSI implementation supporting all three identifier types, together with a parameterizable and well-documented NQ320K construction pipeline. Experimentally, we achieve results that are competitive with or stronger than previous DSI baselines. Moreover, we conduct extensive experiments under model downscaling, covering retrieval effectiveness, parameter efficiency, training methods and decoding strategies, opening novel directions for future research.

Tue 8 SeptInformation Retrieval
The gist
Finding information in large document sets often uses special tools that learn by example, but these tools can be hard to recreate and compare. The authors introduced ReDSI, a new open-source tool that fixes these issues by supporting all original methods and clearly showing how to prepare a popular dataset. Their tests showed that ReDSI works as well or better than prior tools, and they explored how smaller models and different training methods affect results. This work helps make research on document searching more reliable and easier to build upon.
Open 2609.08860v1

Generative retrieval improves documents by using multiple passage identifiers

PDMR: Passage-Driven Multi-ID Document Retrieval

Abstract: Generative Retrieval (GR) models map queries directly to document identifiers, replacing conventional retrieval over external sparse or dense indexes with autoregressive identifier generation. However, most generative retrieval frameworks rely on a single-identifier assumption, mapping each document to a single target sequence. This forces the model to represent all document content with one sequence. Since documents are often multi-faceted, this can lead to lossy representations and reduced robustness to query variation, where multiple query intents must compete for a single generative access path. In this work, we introduce Passage-Driven Multi-ID Retrieval (PDMR), a generative retrieval framework that represents documents through multiple passage-level identifiers. PDMR segments each document and assigns one identifier to each selected passage, which provides multiple semantic entry points for retrieving the same document. This multi-entry representation allows the model to align queries with specific semantic facets, thereby reducing the dependence on a single document-level target. To address the supervision ambiguity of this one-to-many mapping, we formulate training as a multi-target learning problem and explore an objective function designed to distribute probability mass across multiple valid passage-level identifiers. We evaluate PDMR on NQ320K and MS MARCO Document. On NQ320K, PDMR improves over strong generative and non-generative baselines on Recall@1 and MRR@100. On MS MARCO Document, PDMR achieves the best Recall@1 and MRR@10 among the reported methods, while remaining competitive on Recall@10. Controlled ablations further show that passage-level supervision, identifier design, training-query augmentation, and multi-target learning contribute complementary gains.

Tue 8 SeptInformation Retrieval
The gist
Finding information in long documents is hard because a single reference doesn’t capture all the details. The authors created a new way to find documents by breaking them into smaller sections, each with its own identifier. This lets the method match specific parts of a document to different search queries more accurately. They trained their system to handle multiple correct answers and tested it on standard datasets, where it performed better than existing methods.
Open 2609.08762v1

MoEMB improves multimodal embeddings using efficient expert scaling

MoEMB: Scaling Universal Multimodal Embeddings with Efficient Mixture-of-Experts Models

Abstract: Universal multimodal embedding (UME) increasingly demands encoder's capacity for handling a broad range of tasks and modalities with increased complexity. Prior scaling methods either increase the representation size, retrieval effort, or scales the encoder into a heavy multimodal LLM. Recent works, such as Think-Then-Embed (TTE), explore scaling via reasoning tokens. However, embedding models are hard to scale up: increasing parameters directly tradeoffs for the large training batch size that contrastive learning needs, and retrieval has to be served under tight latency. Moreover, UME tasks are diverse in complexity, where scaling up embedders can bring significant redundant computation. In this work, we propose MOEMB, which instead scales UME along the expert axis through mixture-of-experts (MoE), growing encoder capacity while preserving single-vector, non-autoregressive encoding. Through a systematic study of the design space and training recipes for MoE-based UME, MoEMB sets a new state of the art on both MMEB-V2 and MRMR among models trained on public MMEB-family data: with only 3B active parameters, MoEMB surpasses TTE-based methods with >4x active parameters, using significantly less computes. To further improve the scalability and efficiency, we conduct the first comprehensive study of adaptive computation for MoE-based embedding, spanning diverse strategies across training-based and inference-only methods. Together, these results support expert scaling as an effective and efficient direction for UME, with adaptive computation further improving efficiency for MLLM-based embedding models towards large-scale retrieval and recommendation systems.

Tue 8 SeptMachine LearningArtificial Intelligence
The gist
Handling many types of data like images and text together is tricky because embedding models often become too big or slow. The authors show a new way to make these models bigger and smarter without needing much extra computing power. They do this by splitting the work among different 'experts' inside the model, only using some experts for each task. This approach beats older methods while using less computing effort. They also study how to make the model use computing resources better by adjusting which experts are active as needed.
Open 2609.08663v1

Setwise policy updates improve multi-agent language model coordination

SRPO: Setwise Relative Policy Optimization for Multi-Agent LLMs

Abstract: Multi-agent large language models solve complex tasks by coordinating several policies in a shared environment. However, existing reinforcement learning methods usually optimize each response or trajectory separately, even when several outputs jointly cause one state transition. Consequently, the update unit differs from the action executed by the system. To address this problem, we propose SRPO (Setwise Relative Policy Optimization), which treats the active set the minimal set of outputs consumed by one transition, as one multi-agent action. Specifically, SRPO combines member log-ratios into one cardinality-normalized set ratio, assigns one relative advantage, and clips the set once. This formulation unifies division of labor and joint co-evolution as actions with different set sizes. Experiments on mathematical reasoning and multi-turn search demonstrate one training interface for fixed, mixed, and dynamically routed workflows across four model scales, with the strongest macro-average results among the reported comparisons. Optimization diagnostics further characterize its stability under different event reductions and set sizes.

Tue 8 SeptArtificial Intelligence
The gist
Multi-agent large language models often work together to solve complex tasks, but current methods update each agent's actions individually, which can miss how these actions combine to cause results. The authors propose SRPO, a way to treat the combined actions of multiple agents as a single unit, improving how the model learns to coordinate. They tested SRPO on tasks like math reasoning and multi-turn search, showing stable training and better overall performance compared to other methods. This approach helps models handle different teamwork arrangements more effectively.
Open 2609.08452v1

FastE cuts large language model embedding work by 40 percent

FastE: Readout-Triggered Token Compression for LLM Embedding Inference

Abstract: In this study, we identify depth-dependent prefix redundancy in final-readout LLM embedding models, notably across representative backbones including Qwen3-Embedding and Qwen3-VL-Embedding. We find that removing prefix states is substantially more damaging in shallow layers than at greater depth, showing that prefix states become increasingly compressible as the prefix and readout states propagate through the network. To this end, we introduce FastE, a training-free, plug-and-play method. FastE uses a shared fixed threshold on batch-mean readout-prefix alignment as a lightweight online heuristic for selecting when compression occurs, and ranks prefix states by the attention scores they receive from the readout position to determine which states are retained in subsequent layers. Our evaluations demonstrate FastE's ability to substantially reduce computational costs: on NarrativeQA with Qwen3-Embedding-0.6B, it reduces decoder-backbone FLOPs by 40.11% while retaining 99.53% of Full Forward nDCG@10. Across five text embedding benchmarks, two backbone scales, and three cross-modal retrieval tasks, the quality-efficiency trade-off is directly customizable through the maximum removal ratio without retraining. We believe FastE offers practical value for scalable embedding generation in retrieval, indexing, clustering, and multimodal representation systems.

Tue 8 SeptArtificial Intelligence
The gist
Large language models create embeddings that help computers understand text and images, but this process can be slow and costly. The authors found that parts of the initial input become less important as they move deeper through the model, meaning some of that information can be safely ignored without losing much quality. They introduce FastE, a simple method that quickly decides which parts to keep and which to remove during processing, making embedding generation faster and more efficient. FastE does this without needing to retrain the model and works well across many tasks and model sizes.
Open 2609.08407v1

Bottom-up clustering improves semantic ids for generative retrieval

Exploring Bottom-Up Clustering for Creating Semantic IDs

Abstract: The success of generative retrieval has largely been attributed to the use of Semantic IDs, which improve over arbitrary item-level identifiers such as hashes by capturing the semantics of items. The main challenges faced when constructing Semantic IDs, however, is in mapping each identifier to a unique product and capturing information valuable to downstream tasks. Past works have appended additional codewords to de-duplicate item identifiers and utilized residual quantization to create hierarchical clusters. In this work, we present an algorithm for generating Semantic IDs that ensure the identifiers are both unique and preserve the structure of the original embedding. Key to our work is the use of bottom-up clustering to preserve local structure in the embedding space, improving the clustering quality of the resulting Semantic IDs and their utility for downstream generative retrieval.

Tue 8 SeptInformation RetrievalArtificial Intelligence
The gist
Finding unique and meaningful identifiers for items helps search engines retrieve better results. This paper shows how using a method called bottom-up clustering can create semantic IDs that uniquely identify products while keeping their meaning intact. The researchers present a way to group items based on their similarities, which improves how these IDs capture useful information. These improved semantic IDs help systems that generate search results perform better.
Open 2609.08310v1

Dense retrievers improved by tracing query expansion with sparse features

Tracing Query Expansion Effects through Sparse Autoencoder Features

Abstract: Query expansion (QE) is a critical technique in information retrieval that enriches underspecified queries with additional textual context. However, its effect is often unreliable in modern dense retrieval, especially for strong off-the-shelf retrievers without retraining. Existing studies mainly examine expansion quality, semantic drift, or retrieval outcomes, but rarely explain how QE changes dense retrievers internally. In this work, we trace QE effects through sparse autoencoder (SAE) features. Using paired original and expanded queries, we decompose layer-wise retriever representations into sparse latent activations, identify QE-related latents from expansion-induced activation shifts, and interpret them with natural-language descriptions and retrieval cases. Our analysis shows that effective QE induces layer-concentrated changes in sparse latents aligned with retrieval intent and entity attributes, rather than only perturbing final query embeddings. SAE-based activation steering further validates these latents improve retrieval more consistently than random interventions or vanilla QE across four benchmarks, suggesting that SAEs can explain QE effects and offer a lightweight option for precise retrieval behavior modulation without query rewriting or retriever fine-tuning.

Mon 7 SeptInformation Retrieval
The gist
Sometimes search queries are too simple, and adding extra context helps find better results. This paper looks inside how modern search systems change when queries are expanded by showing specific parts of their computations called sparse autoencoder features. The authors found that good query expansions cause meaningful changes in certain layers of the system linked to what the searcher wants and named things. They also show a way to improve search results by adjusting these features directly, without changing the query or retraining the system.
Open 2609.06968v1