FlowSearch: Autonomous Research Workflow

• FlowSearch is a multi-agent framework that operationalizes deep research workflows via dynamically evolving, structured knowledge graphs.
• It integrates LLM agents to decompose queries into parallel sub-tasks and refine outcomes through iterative DAG updates.
• Empirical evaluations show FlowSearch achieving up to 77.9% accuracy on scientific benchmarks, outperforming leading methods.

FlowSearch is a multi-agent research framework that operationalizes deep research workflows via a dynamically evolving, structured knowledge flow graph. The system integrates LLM agents to plan, execute, and refine decomposed research tasks, supporting parallel exploration, real-time reasoning, and iterative adjustment. FlowSearch attains state-of-the-art results across a spectrum of reasoning and scientific benchmarks, offering concrete advances in autonomous scientific discovery and complex information synthesis (Hu et al., 9 Oct 2025).

1. System Architecture and Components

FlowSearch is architected around a dynamic, directed acyclic graph (DAG) formalization of knowledge flow, enabling decentralized, modularized execution and hierarchical decomposition of research queries. The core system comprises three principal LLM-powered components and a summarizer:

• Knowledge Flow Planner: Initializes and recursively expands the knowledge flow DAG $G=(V,E)$, where nodes encode subtasks—distinguished as search, solve, or answer—and edges model logical dependencies. The InternPlanner LLM is fine-tuned to generate graph expansions $f^{expand}_\theta(\cdot)$, iterating until decomposition is complete.
• Knowledge Collector: Identifies “ready” nodes—those with all predecessors in a solved state—and dispatches them in parallel to LLM-driven executors with tool augmentation (web search, OCR, code execution). For node $v_i=(t_i, d_i, s_i, c_i)$, execution semantics are:

$$(s_i, c_i)\;=\;f^{exec}(t_i, d_i\mid \{\,c_j\mid (v_j\!\to\!v_i)\in E\})$$

with $s_i \in \{\text{Success, Failure}\}$ and $c_i$ a distilled knowledge summary.

• Knowledge Flow Refiner: Following each execution cycle, this agent updates the DAG via graph-edit operations: $$\{AddNode, DelNode, ModNode, AddEdge, DelEdge, ModEdge\}$$ as specified by the response of a refinement LLM $f^{refine}(\cdot)$, pruning dead ends and integrating new insights.
• Summarizer / Conclusion Generator: Upon resolution of all dependencies for the query node, generates either a concise answer or a comprehensive scientific report, conditioning on direct predecessors (QA mode) or the full graph (report mode).

The system executes the following loop until task completion: Planner expansion, parallel Collector execution, DAG refinement, and finally, summarization.

2. Formalization of the Dynamic Knowledge Flow

FlowSearch models the evolving research plan as a DAG $G=(V,E)$:

• Nodes: Each node $v_i$ is a tuple:

$f^{expand}_\theta(\cdot)$0

with $f^{expand}_\theta(\cdot)$1 denoting the task type (search, solve, answer), $f^{expand}_\theta(\cdot)$2 a natural-language subtask description, $f^{expand}_\theta(\cdot)$3, and $f^{expand}_\theta(\cdot)$4 the content summary upon successful execution.

• Edges: $f^{expand}_\theta(\cdot)$5, encoding dependency relations $f^{expand}_\theta(\cdot)$6 from a pre-defined set.
• Expansion:

$f^{expand}_\theta(\cdot)$7

Each expansion appends new nodes $f^{expand}_\theta(\cdot)$8 and edges $f^{expand}_\theta(\cdot)$9.

• Execution:

$v_i=(t_i, d_i, s_i, c_i)$0

• Refinement:

$v_i=(t_i, d_i, s_i, c_i)$1

with $v_i=(t_i, d_i, s_i, c_i)$2 outputting a sequence of edit operations as above.

3. Algorithmic Structure

Three key algorithmic procedures govern FlowSearch’s operation:

• INITIAL_PLAN: Recursively expands the initial query node until no further subtasks are proposed, producing the base DAG structure. $v_i=(t_i, d_i, s_i, c_i)$4
• PARALLEL_EXPAND: For each decomposable, pending node, proposes further subtask expansions in parallel, supporting late-arising task branching.
• EXECUTE_AND_REFINE: Executes all ready, dependency-satisfied leaf nodes in parallel; subsequently refines the DAG as new insights or failures are surfaced. $v_i=(t_i, d_i, s_i, c_i)$5

A node evaluation scoring function (e.g., $v_i=(t_i, d_i, s_i, c_i)$3) may guide refinement decisions, such as node splitting or pruning.

4. Empirical Evaluation and Benchmark Results

FlowSearch was evaluated on four challenging benchmarks:

• GAIA: 165 multimodal, tool-oriented items at 3 difficulty levels.
• GPQA-diamond: 198 expert-authored multiple-choice items in biology, chemistry, and physics.
• HLE: 2,500 multimodal questions spanning STEM and humanities.
• TRQA-lit: 172 biomedical target-discovery questions.

Performance metrics are primarily accuracy (%) per domain or difficulty level. FlowSearch demonstrates the following results (excerpted):

Method	GAIA Avg	GPQA Avg	HLE (All)	TRQA
GPT-5	—	85.35	24.76	49.4
OpenAI DR	67.36	—	26.60	60.1
OWL	69.70	—	—	—
MiroFlow	74.50	—	27.20	—
Manus	73.30	—	—	—
FlowSearch (Qwen-o4)	76.96	87.37	30.80	77.9

On GAIA, FlowSearch outperforms OWL, MiroFlow, and Manus. On GPQA-diamond, it achieves 87.37% (versus 85.35% for GPT-5). On HLE, accuracy rises to 30.80%, exceeding leading alternatives. On TRQA, FlowSearch attains 77.9%, a gain of at least 17 percentage points over prior best results (Hu et al., 9 Oct 2025).

5. Component Analysis and Ablations

Ablation studies isolate the contributions of key architectural elements:

• Pipeline variants (from Table 2):

| Components | GAIA Avg | GPQA Avg | |------------------------|----------|----------| | Sequential only | 55.76 | 71.21 | | Flow Planner only | 61.82 | 73.74 | | Flow Planner + Refiner | 76.96 | 87.37 |

The structured planner offers a +6.06% boost on GAIA and +2.53% on GPQA over a sequential baseline; inclusion of the Flow Refiner raises these gains to +15.20% and +15.63%, respectively.

• Planner model (Table 3):

| Planner | GAIA Avg | |---------------------|----------| | Qwen-3-8B | 44.85 | | InternPlanner-8B | 66.06 | | Qwen-3-32B | 64.81 | | InternPlanner-32B | 70.91 |

Fine-tuned InternPlanner LLMs consistently outperform their base counterparts, indicating substantial value from procedure-specific training.

6. Systemic Challenges, Domain Limitations, and Future Directions

6.1 Systemic and Architectural Challenges

• Agent failure cascades necessitate advanced fault isolation.
• Coordination complexity increases nonlinearly with agent scale, requiring efficient inter-agent communication protocols.
• Unpredictable behaviors demand real-time monitoring and potentially, human oversight.
• Scaling issues (compute and network) reinforce the need for dynamic resource management.
• Secure, privacy-preserving multi-agent communication is imperative.

6.2 Domain-Specific Limitations

• Literature coverage remains incomplete; broader and more diverse corpora are needed.
• Hallucination and factual inaccuracies in LLM output underline the importance of external fact-checking and authoritative integration.
• Interoperability with specialized scientific tools is limited; extensible APIs and plugin ecosystems are needed.
• Standard metrics (e.g., Elo-based) may not align with expert evaluation; hybrid assessment modalities are recommended.
• Validation studies have limited cross-disciplinarity and scale.

6.3 Prospective Extensions

• Adoption of modular, multi-stage agent architectures (encompassing generation, reflection, ranking, evolution, and meta-review).
• Fusion of modern generative LLMs with classical multi-agent coordination frameworks (e.g., FIPA, Soar, ACT-R).
• Edge and distributed execution for resilience and efficiency.
• Deeper external toolchain integration, notably with scientific simulators and structured knowledge bases.
• Development of standards for reproducibility, provenance, and ethical governance in autonomous research.

A plausible implication is that FlowSearch’s explicit, DAG-centered orchestration and multi-agent parallelism provide a foundation for scalable, adaptive research agents, potentially generalizing beyond current evaluation domains. The open-source codebase (https://github.com/Alpha-Innovator/InternAgent) offers reproducibility and extensibility for further scientific inquiry (Hu et al., 9 Oct 2025).