Skip to content

FlowSearcher: Synthesizing Memory-Guided Agentic Workflows for Web Information Seeking

🕒 Published (v1): 2026-01-01 · Source: ICLR · Venue: ICLR 2026 · link

Why this paper was selected

ICLR; memory-guided agentic workflow synthesis for non-linear web information seeking

Ask a follow-up

Open an assistant pre-loaded with this paper's context.

💬 Ask ChatGPT✦ Ask Claude

TL;DR

FlowSearcher reframes web information seeking as memory-guided agentic workflow synthesis: rather than issuing tool calls reactively (ReAct-style), it decomposes queries into sub-goals, synthesizes a typed DAG workflow per sub-goal, and draws on a three-level hierarchical memory of past trajectories to guide both workflow orchestration and node-level execution. This yields consistent gains over strong RLHF-trained baselines (+11.5% on GAIA, +9.5% on BrowseComp) without any task-specific parameter training.

Problem

Most web-search agents follow ReAct's linear think–act–observe loop, collapsing branching research tasks into a single-threaded trajectory and discarding all execution experience at episode end. Plan-execute frameworks impose fixed scaffolds that cannot adapt once evidence arrives. The combined result is agents that cannot exploit structural patterns across queries, repeatedly reinvent strategies, and are bottlenecked by the LLM's prompt-time reasoning for complex, multi-faceted queries.

Method

FlowSearcher formulates a research trajectory as \(\{Q, \hat{y}, \Gamma\}\) where \(\Gamma = \{\mu_i, G_i\}\) pairs decomposed sub-questions with workflow graphs. Generation is factored into two levels:

High-level (orchestration). The orchestrator iteratively samples sub-question \(\mu_i\) and synthesizes a typed DAG \(G_i\): $\(P(\Gamma \mid Q, M_0) = \prod_{i=1}^{K} P(\mu_i \mid Q, \Gamma_{<i}, M_{i-1}, \theta_\mu)\, P(G_i \mid Q, \Gamma_{<i}, M_{i-1}, \theta_G, \mu_i)\)$ Nodes are typed (Search, Browse, Summarize, Ensemble, etc.), edges obey a web grammar \(\rho\), and building blocks \(B\) define the composable vocabulary.

Low-level (execution). Each node \(v\) executes an action sequence conditioned on accumulated memory: $\(P(\alpha, o \mid \mu_i, M_{i-1}) = \prod_{t=1}^{K_v} P(\alpha_t, o_t \mid \alpha_{<t}, o_{<t}, \mu_i, M_{i-1})\)$

Structured Compositional Memory organizes past traces into three levels: - Node-level: \(M_v^{\text{node}} = \langle N_v, \alpha^{(v)}, o^{(v)} \rangle\) — type/variant, action sequences, outputs. - Graph-level: \(M_i^{\text{graph}} = \langle G_i, \mu_i, \gamma_i, n_i, \{M_v^{\text{node}}\} \rangle\) — topology, success flag \(\gamma_i \in \{0,1\}\), per-tool usage counts \(n_i \in \mathbb{N}^{|T|}\). - Task-level: \(M_j^{\text{task}} = \langle Q_j, \xi_Q, \{M_i^{\text{graph}}\} \rangle\) — full query context and outcome.

Retrieval uses weighted cosine similarity over query+sub-question embeddings: $\(R(Q^*, \mu^*; \zeta) = \operatorname{arg\,top-}k_{M^\zeta \in M} \left[\delta \frac{E(Q^*)\cdot E(Q)}{|E(Q^*)||E(Q)|} + (1-\delta)\frac{E(\mu^*)\cdot E(\mu)}{|E(\mu^*)||E(\mu)|}\right]\)$ Retrieved traces are distilled into concise insights \(\xi_G\) / \(\xi_v\) and injected into orchestration and node prompts respectively.

Key Contributions

  • Decoupled two-level formulation separating high-level workflow synthesis (DAG generation) from low-level node execution, enabling query-adaptive structure without fixed templates.
  • A compact, expressive building-block library enabling diverse tool-use patterns (Swift-Hit, Parallel, Break-Down, Ensemble, General) composable at inference time.
  • A three-level (node / graph / task) Structured Compositional Memory with a unified retrieval operator that grounds both orchestration and execution in accumulated experience — enabling learning-free generalization across queries.
  • Demonstrated that structural experience reuse is complementary to parameter-level fine-tuning (RLHF), matching or exceeding RLHF-trained agents without any task-specific training.

Results

All metrics are Pass@1.

  • GAIA (avg.): FlowSearcher (QwQ-32B) 71.2% vs. WebThinker-RL 56.4% (+14.8 pp) and WebDancer 61.5% (+9.7 pp); FlowSearcher (Qwen3-32B) 68.2%.
  • GAIA vs. closest ReAct baseline (WebThinker-Base on Qwen-2.5-32B): FlowSearcher improves from 53.8% to 61.5% (+11.5 pp, as cited in abstract).
  • BrowseComp (avg.): FlowSearcher (QwQ-32B) 8.0% vs. WebThinker-RL 2.7% and WebDancer 2.7%; FlowSearcher (Qwen3-32B) 8.1%.
  • BrowseComp vs. WebThinker-Base: +9.5 pp (abstract claim; consistent with table).
  • GPQA-Diamond (avg.): FlowSearcher (QwQ-32B) 71.2% vs. WebThinker-RL 70.7%; FlowSearcher (GPT-4o-mini) 65.7% with only 25% on GAIA Level 3.
  • FlowSearcher with Qwen3-32B achieves 69.2% GAIA avg., 68.2% GPQA avg., 8.1% BrowseComp avg.
  • No-agency baselines (best: DeepSeek-R1-671B) reach at most 31.1% GAIA avg. and 0.8% BrowseComp.
  • OpenAI Deep Research (closed-source) reaches 67.4% GAIA avg. and 51.5% BrowseComp avg. for reference.

Limitations

  • Memory quality degrades if early retrieved experiences are incorrect or misleading; no explicit mechanism for memory correction or forgetting is described.
  • Memory retrieval relies on embedding similarity, which may fail for structurally similar but semantically distant queries (or vice versa).
  • The building-block vocabulary \(B\) and web grammar \(\rho\) are manually defined; coverage of novel tool-use patterns depends on this fixed design.
  • BrowseComp absolute scores remain low (≤12% for all systems including FlowSearcher), suggesting hard-browsing tasks remain unsolved.
  • Evaluation is limited to text-only questions on three benchmarks; multimodal or structured-output web tasks are not assessed.
  • No ablation of the \(\delta\) balancing factor in retrieval, nor sensitivity analysis of top-\(k\) retrieval size, is presented in the excerpted text.

Relevance to Harnesses / Meta-Harnesses

FlowSearcher is a direct instance of a meta-harness pattern: it does not hardcode a single agent loop but instead synthesizes and reuses workflow programs (DAGs) at runtime, acting as an orchestration layer above tool-calling agents. The three-level memory that consolidates past workflow executions into reusable structural experience is analogous to a harness accumulating meta-knowledge about which sub-harness configurations work for which query types. The decoupled orchestrator–executor design mirrors the harness/sub-harness split central to meta-harness architectures, and the building-block library with composable typed nodes represents a formal grammar for harness construction. This work offers a concrete, empirically validated blueprint for how harnesses can learn from their own execution history to self-improve without retraining.