LM-Searcher: LLM-Based Search Systems

• LM-Searcher is a family of language model-based search systems that integrate query interpretation, planning, and external tool usage for deep information retrieval.
• These systems employ interleaved reasoning–action–observation loops and varied control architectures to enhance search robustness and efficiency.
• Empirical studies highlight sample-efficient training and advanced parallel processing, enabling applications from web query answering to neural architecture search.

Searching arXiv for papers related to “LM-Searcher” and LLM-based search agents. LM-Searcher denotes a class of language-model-centered search systems in which a LLM does not merely answer after retrieval, but participates in query interpretation, search planning, tool invocation, evidence extraction, memory management, and final synthesis. In the recent literature, the expression is used in two related senses. Broadly, it refers to LLM-based deep information-seeking systems, collaborative search agents, multimodal browsing agents, and other search-oriented controllers over external environments. Narrowly, “LM-Searcher” is also the exact title of a 2025 paper on cross-domain neural architecture search with LLMs via unified numerical encoding, where the “search” target is neural architectures rather than web evidence (Sun et al., 22 May 2025, Gong et al., 2024, Hu et al., 6 Sep 2025). This suggests that “LM-Searcher” is best treated as a family resemblance term rather than a single canonical architecture.

1. Terminology and conceptual scope

In the deep-search literature, the basic problem is not ordinary one-shot retrieval. Questions often cannot be answered from parametric memory alone or from a single retrieved passage; instead, the model must decompose the request, decide what to search next, retrieve iteratively, summarize noisy evidence, and stop at an appropriate point. “SimpleDeepSearcher” explicitly frames this as deep information seeking and contrasts it with vanilla RAG, which often issues one retrieval query—usually the original question—and conditions generation on the returned passages (Sun et al., 22 May 2025).

Other systems extend the same search-centered idea into distinct settings. “CoSearchAgent” places the search loop inside Slack multi-party conversations, where the query may be implicit in the preceding dialogue and may require contextual rewriting before search (Gong et al., 2024). “O$^2$-Searcher” treats open-domain open-ended QA as a search-control problem in which the model alternates between reasoning, search, and answer production, rather than merely generating a final answer from a fixed context (Mei et al., 22 May 2025). “Flash-Searcher” generalizes the search-agent frame further by recasting execution as a directed acyclic graph of subtasks, allowing concurrent search and browsing branches instead of a single serialized chain (Qin et al., 29 Sep 2025).

At the same time, the exact title “LM-Searcher” is used by a distinct line of work in neural architecture search. There the target is not web-grounded information seeking but architecture optimization across CNNs, LoRA configurations, transformers, and audio DAGs using a universal numerical representation called NCode and an instruction-tuned LLM that selects high-performing candidates from a pool (Hu et al., 6 Sep 2025). The shared theme is that an LLM is used as a search policy over an external structured space; the searched object, however, differs substantially.

2. Canonical control loops and architectural patterns

A recurring pattern is an interleaved reasoning–action–observation loop. In “SimpleDeepSearcher,” the search-with-think framework is organized around “reasoning-searching-summarizing-generating.” Given a prompt $p$, the model emits reasoning $r$, a search query $q$ delimited by special tokens $t_s$ and $t_e$, receives summarized document observations $d$, and ultimately produces answer $a$. The reconstructed training trajectory is

$$x=\bigl(p,\; r_1,\; t_s q_1 t_e,\; d_1,\; r_2,\; t_s q_2 t_e,\; d_2,\; \ldots,\; r_T,\; a\bigr),$$

which makes the search policy part of the generated sequence rather than an external fixed pipeline (Sun et al., 22 May 2025).

In collaborative conversational search, the loop begins earlier, at query interpretation. “CoSearchAgent” formalizes contextual rewriting as

$q_{rewrite}=F_{rewrite}(U,q),$

where $p$0 is the multi-user dialogue context and $p$1 is the current user request. If ambiguity persists, clarification is generated via

$p$2

after which search results are transformed into query-conditioned references and used for grounded answer generation

$p$3

The important architectural point is that conversational context becomes part of the search state, not merely preamble text (Gong et al., 2024).

Several papers make the controller more explicit. “RE-Searcher” inserts a goal-oriented loop in which each search step contains a declared search goal, a query tied to that goal, and an explicit reflection judgment of whether the retrieved evidence satisfies that goal. “APEX-Searcher” separates planning from execution: a planner first emits a sequence of sub-questions $p$4, potentially with references such as #1, and an executor then performs iterative retrieval for each sub-question (Fu et al., 30 Sep 2025, Chen et al., 14 Mar 2026). “Flash-Searcher” pushes the idea further by defining a decomposition

$p$5

where $p$6 are subtasks and $p$7 are dependencies, so independent branches can be executed concurrently (Qin et al., 29 Sep 2025).

These variants differ in controller shape—linear ReAct loop, goal-reflection loop, planner–executor hierarchy, or DAG scheduler—but they share the same design move: search is treated as a policy over external actions, not as a single retrieval prelude to answer generation.

3. Training paradigms and supervision signals

One major divide in the literature concerns whether search capability is learned mainly from high-quality supervised trajectories or from reinforcement learning over interactive search. “SimpleDeepSearcher” is the clearest statement of the supervised position: it argues that the main bottleneck is the quality and realism of search trajectories rather than optimizer sophistication, and reports that supervised fine-tuning on only 871 curated examples outperforms RL-based baselines on five benchmarks (Sun et al., 22 May 2025). “OpenSeeker” makes a related claim at larger scale: using simple SFT on 11.7k synthesized samples, it reaches strong performance on BrowseComp, BrowseComp-ZH, xbench-DeepSearch, and WideSearch, while explicitly presenting data openness as the crucial missing resource for the open community (Du et al., 16 Mar 2026).

By contrast, several systems retain RL as the central training mechanism. “MemSearcher” uses end-to-end RL with multi-context GRPO, where a trajectory is composed of turn-level conversations under changing memory states, and the same trajectory-level advantage is propagated to all turn-level interactions. It is trained on the same data as Search-R1 and reports average relative gains of about $p$8 on Qwen2.5-3B-Instruct and $p$9 on Qwen2.5-7B-Instruct (Yuan et al., 4 Nov 2025). “O$r$0-Searcher” adopts GRPO as well, but introduces different reward structures for closed-ended and open-ended QA; the open-ended reward combines format, diversity, and factual alignment terms rather than relying on exact match alone (Mei et al., 22 May 2025). “Deliberative Searcher” adds a constrained RL formulation in which correctness is optimized under a soft reliability constraint, with self-reported confidence $r$1 and a Lagrangian update over a reliability target (Yin et al., 22 Jul 2025).

A third line adapts training to new model families. “DLLM-Searcher” treats diffusion LLMs as potentially attractive search-agent backbones because of parallel decoding, but argues that existing dLLMs have weak reasoning and poor tool-call formatting. It therefore uses a two-stage post-training pipeline of Agentic SFT and Agentic VRPO, together with Agentic Noising and Agentic ELBO, to train only on agent-generated regions while preventing tool-response leakage inside diffusion blocks (Zhao et al., 3 Feb 2026).

Across these works, one common implementation detail is tool-response masking. “SimpleDeepSearcher,” “MemSearcher,” “LMM-Searcher,” and “DLLM-Searcher” all state, in different forms, that externally retrieved content or tool-response tokens are masked in the loss so the model learns search and reasoning behavior rather than simply imitating environment text (Sun et al., 22 May 2025, Yuan et al., 4 Nov 2025, Du et al., 14 Apr 2026, Zhao et al., 3 Feb 2026). A plausible implication is that LM-Searcher training increasingly treats external observations as state rather than as output targets.

4. State management, environments, and memory

A second major design axis concerns what counts as the agent’s state and how that state is kept manageable. “SimpleDeepSearcher” criticizes RL methods trained only in artificial environments with static corpora and explicitly synthesizes trajectories in a real web environment using a commercial search API, raw HTML extraction, multiple reasoning paths per query, and aggressive curation of input diversity and output quality (Sun et al., 22 May 2025). “CoSearchAgent” also uses live web search, but in a lightweight conversational wrapper: it captures the preceding 20 Slack utterances, retrieves around 10 results through SerpApi, truncates each fetched page to the first 5000 tokens, and replaces ordinary search snippets with LLM-extracted references (Gong et al., 2024).

The context-length problem becomes central in long-horizon settings. “MemSearcher” identifies the trade-off between full-history ReAct context, which preserves information integrity but grows noisily, and current-turn-only context, which is efficient but lossy. It replaces the full transcript with a bounded natural-language memory $r$2, so that the per-turn context becomes

$r$3

with a maximum memory size of 1,024 tokens and an 8K context window (Yuan et al., 4 Nov 2025). “LMM-Searcher” extends the same concern to multimodal browsing: images are stored externally and represented in context only by lightweight textual identifiers $r$4, with a mapping

$r$5

Visual content is loaded on demand through fetch_image, which turns multimodal search into a coarse-to-fine active-perception process rather than eager insertion of all images into the prompt (Du et al., 14 Apr 2026).

Environment design also changes what the model learns. “O$r$6-Searcher” uses a locally simulated environment that combines a cached open-ended web corpus and a Wikipedia index, arguing that RL on the live web is too slow and unstable for training (Mei et al., 22 May 2025). “Flash-Searcher” instead keeps the live-web character of the task but changes the execution substrate: the environment is navigated through a dynamically refined DAG, and multiple tool calls may be executed in parallel if the readiness predicate $r$7 (Qin et al., 29 Sep 2025).

These systems converge on a shared systems lesson: state design is not a peripheral engineering detail. Whether the agent carries raw transcript, summarized memory, UID references to visual files, or a DAG of pending subtasks materially changes both computational cost and reasoning behavior.

5. Evaluation regimes and empirical patterns

Evaluation is highly heterogeneous. The literature uses F1, Exact Match, LLM-as-Judge scores such as LasJ or $r$8, string-contained answer accuracy $r$9, retrieval metrics such as Recall@K and MRR, open-ended metrics such as LFS, and task-specific scores such as SPL, PE, BLEU, PER, IoU, and normalized Borda score. This suggests that “LM-Searcher” is not yet a benchmark-unified field; systems are often optimized for different search substrates and answer types.

System	Setting	Representative reported result
SimpleDeepSearcher (Sun et al., 22 May 2025)	Web-grounded deep search	SFT on 871 curated samples outperforms RL-based baselines on five benchmarks
MemSearcher (Yuan et al., 4 Nov 2025)	RL search with compact memory	Average relative gains of about +11% on 3B and +12% on 7B
O$q$0-Searcher (Mei et al., 22 May 2025)	Open-ended and closed-ended QA	0.2236 average F1 on O$q$1-QA local setting; 0.391 average on closed-ended QA with a 3B model
DLLM-Searcher (Zhao et al., 3 Feb 2026)	Diffusion-LM search agents	Average $q$2, $q$3; P-ReAct gives about 15% acceleration
RE-Searcher (Fu et al., 30 Sep 2025)	Goal-oriented robust search	0.449 average EM on Qwen2.5-7B; lower degradation under query perturbations
Flash-Searcher (Qin et al., 29 Sep 2025)	DAG-based parallel web execution	67.7% on BrowseComp and 83% on xbench-DeepSearch, with up to 35% fewer steps
OpenSeeker (Du et al., 16 Mar 2026)	Fully open SFT search agent	29.5 on BrowseComp, 48.4 on BrowseComp-ZH, 74.0 on xbench, 59.4 item F1 on WideSearch

Several empirical themes recur. First, high-quality supervised trajectory data can be surprisingly sample-efficient: the 871 examples of “SimpleDeepSearcher” and the 11.7k examples of “OpenSeeker” are both presented as evidence that realistic, curated trajectories can rival or exceed more elaborate RL pipelines (Sun et al., 22 May 2025, Du et al., 16 Mar 2026). Second, robustness metrics matter. “RE-Searcher” explicitly measures instability through “always right” and “random right” categories and studies perturbations created by deleting, adding, or replacing a word in a search query, reporting that explicit search-goal articulation and self-reflection improve resilience to noisy retrieval (Fu et al., 30 Sep 2025). Third, speed and parallelism are becoming first-class objectives. “Flash-Searcher” reports fewer outer execution steps by increasing tool calls per step, while “DLLM-Searcher” attacks latency by overlapping tool execution with continued diffusion-style decoding (Qin et al., 29 Sep 2025, Zhao et al., 3 Feb 2026).

6. Domain-specific and modality-specific variants

The LM-Searcher pattern appears in a wide range of specialized domains. In collaborative search, “CoSearchAgent” is a Slack-native LLM plugin that rewrites context-dependent requests, asks a clarifying question when needed, retrieves web results, extracts query-relevant references from pages, and returns cited answers to all users in the conversation (Gong et al., 2024). In agriculture, “Language-Guided Object Search in Agricultural Environments” uses GPT-4o mini to score object-to-object semantic priors $q$4, converts those priors into waypoint scores

$q$5

and plans search paths for a Boston Dynamics Spot robot, reporting 0.80 success rate and 0.67 SPL in real-world trials (Balaji et al., 3 Mar 2025).

In finance, “FinSearch” turns the search problem into graph-structured execution over financial APIs. It decomposes a question into a DAG $q$6, assigns each node to Yahoo Finance, NewsAPI, or GoogleSearch, rewrites downstream sub-queries based on intermediate results, and weights evidence by temporal proximity through

$q$7

On FinSearchBench-24, it reports 76.20% with GPT-4o and substantial gains over Perplexity Pro (Li et al., 2024).

Formal mathematics yields yet another specialization. “Lean Finder” is a dense retrieval system for Lean and mathlib that maps natural-language user queries, informalized statements, proof states, and noisy formal fragments into a shared embedding space with Lean declarations, and aligns the retriever using feedback and retrieval-adapted DPO. It reports over 30% relative improvement on informalized statements and a real-user Top-3 preference rate of 81.6% (Lu et al., 8 Oct 2025).

Finally, the exact-title paper “LM-Searcher” defines search over neural architectures rather than documents. It encodes architectures as numerical strings called NCode, reformulates NAS as candidate selection

$q$8

and instruction-tunes LLaMA-3.1-8B on 228k optimization trajectories constructed by pruning-based subspace sampling (Hu et al., 6 Sep 2025). This narrow usage preserves the core search-agent motif—an LLM chooses among external structured alternatives—but divorces it from retrieval over text or the web.

7. Recurrent bottlenecks, controversies, and open directions

Several contested design questions organize the field. One concerns data versus optimizer. “SimpleDeepSearcher” argues that better trajectories can beat better trainers, while “OpenSeeker” presents open training data as the decisive missing variable for reproducing frontier search agents (Sun et al., 22 May 2025, Du et al., 16 Mar 2026). Another concerns realism versus controllability. Systems trained in static local corpora avoid live-web cost and instability, but papers such as “SimpleDeepSearcher” criticize distributional mismatch, whereas “MemSearcher” explicitly notes that its evaluation remains tied to a local Wikipedia-based environment even though real-web generalization is only partially tested (Sun et al., 22 May 2025, Yuan et al., 4 Nov 2025).

A second controversy concerns trustworthiness. “Deliberative Searcher” argues that retrieval and multi-step reasoning are insufficient if the model remains miscalibrated, and introduces a reliability reward based on alignment between correctness and self-reported confidence (Yin et al., 22 Jul 2025). “Know Where to Go” pushes the issue down to the source level, treating existence, accessibility, consistency, validity, and evidence precision as core retrieval properties rather than afterthoughts (Shi et al., 2023). This suggests that LM-Searcher research is shifting from “can it retrieve?” toward “can it know when retrieved evidence is enough, and can it justify what it trusts?”

A third bottleneck is fragility under environmental complexity. “RE-Searcher” quantifies how tiny query perturbations can send an agent into different retrieval basins, producing unstable search trajectories (Fu et al., 30 Sep 2025). “Flash-Searcher” treats serial execution itself as a major source of inefficiency, replacing long linear tool-use chains with DAG-based parallelism (Qin et al., 29 Sep 2025). “MemSearcher” argues that the transcript-as-state convention creates context explosion, while “LMM-Searcher” shows that multimodal versions of the same problem require external file-based visual memory (Yuan et al., 4 Nov 2025, Du et al., 14 Apr 2026).

The resulting picture is not one of convergence on a single LM-Searcher blueprint. Rather, the literature repeatedly returns to a small set of bottlenecks—trajectory realism, search robustness, calibration, context management, latency, and data openness—and proposes different architectural remedies depending on the search domain. This suggests that the modern LM-Searcher is less a finished model class than an evolving systems paradigm for coupling LLM reasoning with external search spaces.