LongSeeker: Elastic Context Orchestration

• LongSeeker is a long-horizon search agent that uses elastic context orchestration to dynamically manage its working context during extended search operations.
• It integrates the Context-ReAct paradigm by coupling reasoning with meta-operations like Compress, Rollback, and Snippet to optimize memory and reduce hallucinations.
• Empirical evaluations demonstrate stable context sizes and improved accuracy on benchmarks, outperforming traditional append-only ReAct approaches.

LongSeeker is a long-horizon search agent introduced as an instance of elastic context orchestration, a design in which the agent treats its working context as a controllable state rather than as an append-only transcript. It instantiates the Context-ReAct paradigm, under which each step jointly produces reasoning, a set of context-management meta-operations, and a tool call. LongSeeker is fine-tuned from Qwen3-30B-A3B on 10k synthesized Context-ReAct trajectories and is reported to achieve 61.5% on BrowseComp and 62.5% on BrowseComp-ZH, while keeping average context size stable, plateauing around 15k tokens even on runs of up to 300 steps (Lu et al., 6 May 2026).

1. Problem formulation and motivation

LongSeeker is motivated by a specific failure mode of long-horizon search agents: as they plan, browse, and accumulate observations, their working context grows monotonically and begins to degrade both efficiency and reliability. In the formulation used for Context-ReAct, a standard ReAct step is written as

$S_i^{std} = (r_i, c_i, o_i)$

where $r_i$ is the chain-of-thought, $c_i$ the tool call, and $o_i$ the returned observation. The append-only history at time $t$ is

$H_t = [S_1^{std}, S_2^{std}, \ldots, S_t^{std}],$

and the working context state is denoted $C_t$, typically with $C_t = H_t$ or a managed variant. Under naive accumulation, token cost follows

$cost(C_{t+1}) = cost(C_t) + |S_{t+1}|,$

with $cost(C) \approx |C|$ as a token-cost proxy (Lu et al., 6 May 2026).

This setup yields three linked difficulties. First, inference cost and latency scale roughly with context length. Second, the signal-to-noise ratio deteriorates because stale or redundant traces remain visible to later reasoning steps. Third, hallucination risk increases because factual details are repeatedly paraphrased or re-generated instead of being preserved in a controlled form. A common misconception is that sufficiently large context windows eliminate this problem. LongSeeker explicitly argues otherwise: even with a large 256k model context window and a maximum tool-call budget of 300, the agent still benefits from active memory shaping because the issue is not only capacity, but also the quality and relevance structure of the context presented to the model (Lu et al., 6 May 2026).

2. Context-ReAct as the core agentic paradigm

Context-ReAct generalizes ReAct by inserting context management directly into the decision loop. A Context-ReAct step is defined as

$r_i$0

where

$r_i$1

is a list of meta-operations applied to the current context before the next observation is appended. The effective transformation is

$r_i$2

with composition

$r_i$3

The managed context at the end of step $r_i$4 is then

$r_i$5

In procedural terms, the model first generates reasoning, meta-operations, and a tool call in a single pass; the meta-operations are then executed; the environment returns the observation; and only after that is the current step appended (Lu et al., 6 May 2026).

The central design choice is that the agent decides when, where, and how to reshape memory before new evidence arrives. This differs from threshold-triggered summarization policies such as “summary-on-overflow,” because the management policy is state-dependent and co-generated with reasoning itself. The paper presents this as a unified loop in which context is neither a passive buffer nor an external post-processing artifact, but a first-class control variable. In practice, this means LongSeeker can preserve newly verified evidence verbatim, compress older resolved subthreads, abandon dead-end branches, or delete clearly irrelevant steps before they contaminate later inference (Lu et al., 6 May 2026).

3. Atomic operations and theoretical properties

Context-ReAct provides five atomic operations: Skip, Compress, Rollback, Snippet, and Delete. They act on a context

$r_i$6

where each step has the form $r_i$7.

Operation	Semantics	Fidelity / complexity
Skip	$r_i$8	Identity, $r_i$9
Compress	Replace a contiguous range $c_i$0 with summary $c_i$1	Lossy, $c_i$2
Rollback	Truncate to step $c_i$3 and summarize with $c_i$4	Localized loss, $c_i$5
Snippet	Replace an observation with an exact substring slice	Lossless, $c_i$6
Delete	Remove step $c_i$7 entirely	Exact removal, $c_i$8

The paper gives the operations explicitly. For example,

$c_i$9

$o_i$0

$o_i$1

and

$o_i$2

The distinction between Snippet and Compress is especially important. Snippet is pointer-based and lossless for the retained segment, which the paper highlights as eliminating hallucination on exact literals such as numbers, entities, URLs, code, or quotes. Compress is generative and lossy, but offers the largest token savings on long spans (Lu et al., 6 May 2026).

A common misunderstanding is that the five operations are merely an ad hoc toolkit. The paper instead proves a formal expressivity result: Compress alone is expressively complete. The theorem states that for any $o_i$3, there exists a single configuration $o_i$4 such that

$o_i$5

Equivalently, for any history-to-history transformation $o_i$6, one can choose $o_i$7 so that

$o_i$8

This establishes universality, but not practical optimality. The specialized operators remain important because they provide efficiency and fidelity guarantees that Compress does not. Skip introduces zero cost and zero risk; Snippet preserves exact strings without regeneration; Delete removes noise without abstraction; and Rollback structurally discards failed suffixes while retaining a localized summary of lessons learned (Lu et al., 6 May 2026).

4. Model, supervision, and training pipeline

LongSeeker is built by supervised fine-tuning rather than reinforcement learning. The base model is Qwen3-30B-A3B, and each step is emitted in a four-field structured format: >, <meta_tool_call>, <motivation>, and <standard_tool_call>. The supervised objective is standard next-token prediction over the full structured output, conditioned on the managed context:

$o_i$9

Here $t$0 is the context after applying the previous turn’s meta-operations (Lu et al., 6 May 2026).

The training set consists of 10,000 multi-hop questions from OpenSeeker, with 9k English and 1k Chinese. A teacher model, DeepSeek-V3.2, solves each question under Context-ReAct and produces joint $t$1 decisions in one pass, together with the motivation field. Trajectories with correct structured formatting form the training set. The tool-calling protocol remains standard ReAct-style web search and browse interaction, with the environment returning observations $t$2. The paper reports a maximum tool-call budget of 300 in experiments and emphasizes that, although the backbone supports a 256k context window, LongSeeker typically operates far below that budget through elastic orchestration (Lu et al., 6 May 2026).

This training design has two notable implications. First, LongSeeker’s behavior is learned from explicit demonstrations of context shaping rather than from external heuristics. Second, the reported system does not use RL or rejection sampling to optimize operation policies; the paper lists this as a current supervision limit and as a direction for future work. Reproducibility resources are also provided: code at https://github.com/PolarSeeker/LongSeeker and a model release at https://huggingface.co/PolarSeeker/LongSeeker-30B-SFT (Lu et al., 6 May 2026).

5. Empirical performance, ablations, and behavioral characteristics

LongSeeker is evaluated on BrowseComp, BrowseComp-ZH, xbench-2505, and the GAIA text-only subset. The headline scores are 61.5% on BrowseComp, 62.5% on BrowseComp-ZH, 78.0 on xbench-2505, and 77.7 on GAIA-text. On BrowseComp and BrowseComp-ZH, the reported baselines are Tongyi DeepResearch at 43.2% / 46.7% and AgentFold at 36.2% / 47.3%, respectively. The evaluation setup reports 200 questions per benchmark for BrowseComp and BrowseComp-ZH, with accuracy measured on answerable questions under a budgeted number of tool calls (Lu et al., 6 May 2026).

The most characteristic empirical result is not only accuracy but context-growth behavior. On 200 BrowseComp questions, LongSeeker keeps average context size stable, plateauing around 15k tokens even up to 300 steps, whereas append-only ReAct baselines show near-linear growth. This is presented as direct evidence that the learned mixture of Rollback, Delete, Snippet, and Compress is sufficient to maintain an information-dense working context without relying on crude truncation. The paper also reports ablations against “Summary-on-overflow” and “Discard-all” strategies implemented on the same base model; Context-ReAct attains higher task scores under the same step budget, supporting the claim that proactive, fine-grained operations outperform coarse, threshold-triggered policies (Lu et al., 6 May 2026).

The qualitative case study described in the appendix illustrates how the operations interact. Compress consolidates steps 1–4, Skip leaves step 5 unchanged, Delete removes a redundant step 6, Rollback discards an unproductive branch beyond step 7, and Snippet preserves exact strings from retrieved pages. The paper interprets this as evidence that the method does not merely shorten context, but restructures it. A further misconception addressed implicitly by these results is that the agent must choose between compression and fidelity. LongSeeker’s design treats that as a selective trade-off: abstraction is applied where subgoals are resolved, while precision-critical material is carried forward losslessly through Snippet (Lu et al., 6 May 2026).

6. Related systems, limitations, and broader significance

LongSeeker belongs to a broader family of long-horizon “seeker” systems, but its specific contribution is to make context manipulation itself part of the action space. In VSearcher, the core emphasis is different: a static multimodal model is turned into a web-grounded, multi-turn search agent via an SFT-then-RL pipeline, with text_search, image_search, and visit tools, a maximum of 30 tool calls per episode, and time horizons up to 2 hours 30 minutes per trajectory. VSearcher optimizes whole trajectories with GRPO and evaluates on multimodal search benchmarks including MM-SearchExam, where it reports 19.3 and surpasses recent multimodal search agents on several benchmarks (Zhang et al., 3 Mar 2026). A plausible implication is that VSearcher and LongSeeker address complementary bottlenecks: VSearcher concentrates on live multimodal tool-use and trajectory-level RL, whereas LongSeeker concentrates on internal memory shaping under long horizons.

A second adjacent system is DocSeeker, which addresses long document understanding rather than open-ended web browsing. DocSeeker uses a structured Analysis–Localization–Reasoning workflow, page-aware inputs,

$t$3

and grounded outputs with explicit evidence pages. It combines SFT on distilled ALR-CoT, Evidence-aware GRPO, and Evidence-Guided Resolution Allocation for memory-efficient multi-page training, reporting 40.1 Acc on MMLongBench-doc and near-stability between evidence-only and full-document settings (Yan et al., 14 Apr 2026). This suggests a broader architectural pattern across recent work: long-horizon performance improves when models separate evidence seeking from final reasoning and when they actively control either their retrieval set, their visual resolution budget, or their working context.

The LongSeeker paper also identifies several limitations. Summarization drift can cause Compress to omit or distort details; over-pruning can discard useful context; and deciding when to Rollback rather than Compress requires nuanced judgment. The current training regime relies on synthetic teacher trajectories and supervised learning only, with no RL over meta-operations. Future work proposed in the paper includes reinforcement learning for operation policies, richer safety checks for lossless retention, extension to other domains such as software agents and legal discovery, and uncertainty-aware compression (Lu et al., 6 May 2026).