Source-linked AI summary
MiroFlow: Towards High-Performance and Robust Open-Source Agent Framework for General Deep Research Tasks
Shiqian Su, Sen Xing, Xuan Dong, Muyan Zhong, Bin Wang, Xizhou Zhu, Yuntao Chen, Wenhai Wang, Yue Deng, Pengxiang Zhu, Ziyuan Liu, Tiantong Li, Jiaheng Yu, Zhe Chen, Lidong Bing, Jifeng Dai
TL;DR
Standalone LLMs and existing agent frameworks remain limited on complex, dynamic tasks requiring external interaction, flexible workflows, and reliable long-horizon execution. MiroFlow addresses these gaps with a hierarchical open-source framework combining an agent graph, robust workflow, and optional heavy-reasoning mode. Across multiple benchmarks, it achieves reproducible state-of-the-art performance without task-specific tuning and generalizes across heterogeneous environments.
Problem
Standalone LLMs and existing agent frameworks are limited by insufficient external interaction, inflexible workflows, unstable execution, and restricted generalization across complex deep research tasks.
Method
MiroFlow combines a hierarchical architecture with an agent graph, robust workflow mechanisms, and optional heavy reasoning for flexible and reliable task execution.
Results
MiroFlow achieves reproducible state-of-the-art performance across multiple agent benchmarks without task-specific tuning and generalizes across heterogeneous environments.
Takeaways & Limitations
MiroFlow offers a unified, transparent, and reproducible open-source foundation for accessible and scalable deep research agent development.
Abstract
from arXiv · showhide
Despite the remarkable progress of large language models (LLMs), the capabilities of standalone LLMs have begun to plateau when tackling real-world, complex tasks that require interaction with external tools and dynamic environments. Although recent agent frameworks aim to enhance model autonomy through tool integration and external interaction, they still suffer from naive workflows, unstable performance, limited support across diverse benchmarks and tasks, and heavy reliance on costly commercial APIs. In this work, we propose a high-performance and robust open-source agent framework, termed MiroFlow, which incorporates an agent graph for flexible orchestration, an optional deep reasoning mode to enhance performance, and a robust workflow execution to ensure stable and reproducible performance. Extensive experiments demonstrate that MiroFlow consistently achieves state-of-the-art performance across multiple agent benchmarks, including GAIA, BrowseComp-EN/ZH, HLE, xBench-DeepSearch, and notably FutureX. We hope it could serve as an easily accessible, reproducible, and comparable baseline for the deep research community.
1. Introduction
MiroFlow addresses the limitations of standalone LLMs and existing agent frameworks with a flexible, robust, open-source design. It combines hierarchical orchestration, an agent graph, robust workflow execution, and heavy reasoning, achieving reproducible state-of-the-art performance across diverse benchmarks without task-specific tuning.
- Standalone LLMs struggle with complex real-world tasks requiring multi-step planning, dynamic reasoning, external tools, and tool coordination.
- Existing agent frameworks remain limited by inflexible hard-coded workflows and unstable execution in complex deep research scenarios.
- The framework supports open-source tools, libraries, and benchmarks to enable cost-efficient, transparent, and scalable deployment.
- MiroFlow achieves reproducible state-of-the-art performance across representative agent benchmarks using the same codebase without task-specific tuning.The reported evaluations span GAIA, BrowseComp-EN/ZH, HLE, xBench-DS, and FutureX.
- MiroFlow uses a hierarchical architecture in which the control tier coordinates agent and foundation tiers for general task scheduling and modular extensibility.
- Its agent graph, robust workflow, and optional heavy-reasoning mode support flexible task composition, fault mitigation, self-verification, and more consistent reasoning.The robust workflow includes task normalization, retries, and fault isolation.
2. Related Work
Related work has progressed from self-contained LLMs toward reasoning-enhanced models and tool-using agents. Agent frameworks increasingly orchestrate planning, tool access, specialist models, and interaction loops, motivating more capable framework designs for complex tasks.
- Scaling and reasoning advances have improved LLM capabilities, but self-contained models remain constrained by outdated knowledge and limited external interaction.
- LLM-based agents combine foundation models with frameworks that manage task decomposition, state, and external feedback.
- Modern foundation models increasingly support multi-step reasoning, planning, and native function calling for tool-augmented decision-making.
- Early agent frameworks added tool access through API calling, specialist-model delegation, and the ReAct Thought–Action–Observation loop.
3. MiroFlow Agent Framework
MiroFlow organizes agents and tools through a three-tier architecture and flexible agent graph, while adding heavy reasoning and robust execution mechanisms for complex tasks. Its workflow supports modular collaboration, verification, fault handling, and reproducible operation.
- 3.1. Overall Architecture: MiroFlow uses control, agent, and foundation tiers to orchestrate workflows, define agent behavior, and provide reusable models, tools, and processors.The control tier maintains logs and checkpoints, while the other tiers separate coordination, execution units, and infrastructure.
- 3.1. Overall Architecture: Agent nodes encapsulate prompts, models, tools, processors, and contexts, and communicate through structured messages to support scalable collaboration.Users can define, manage, and adjust independent work units without coupling them to the control tier.
- 3.2. Agent Graph: The agent graph uses directed, configurable dependencies so tasks can execute sequentially, in parallel, or through interwoven workflows rather than fixed chains.A declare-then-define approach lets agents specify callable sub-agents and tools while preserving task dependencies.
- 3.4. Heavy-Reasoning Mode: Heavy-reasoning mode activates multiple agents for ensemble or verification strategies, scaling computation and inference time for more reliable results.Ensemble execution aggregates parallel outputs, while verification iterates between answer generation and feedback under limits on agents, rounds, and wall-clock time.
- 3.3. Robust Workflow: The robust workflow addresses instability from instruction failures, search randomness, connection problems, and tool or network errors through normalization, retries, and fault isolation.After retries, errors are converted into typed, summarized artifacts and informative messages for upper layers.
4. Experiment
MiroFlow is evaluated across diverse benchmarks and ablations, showing broad performance, robustness across tool configurations, and gains from workflow and reasoning components.
- Benchmark Results: MiroFlow achieves state-of-the-art performance across major benchmarks, outperforming commercial, closed-source, and open-source agent frameworks.It also supports nearly all evaluated agent benchmarks, whereas many existing agents do not generalize across them.
- Benchmark Results: MiroFlow supports both open-source and closed-source language models while consistently delivering strong performance across models.The framework nearly doubles standalone GPT-5 performance on FutureX.
- Robustness Ablations: Message normalization and retry mechanisms improve accuracy and reduce score variability, supporting stable and reproducible performance.Removing either mechanism degrades performance, while both ablations increase the standard deviation of benchmark scores.
- Heavy-Reasoning Ablations: Heavy-reasoning configurations consistently improve performance by using ensembles, verification loops, or additional agent nodes.The verification policy uses a 10-step iterative generator–verifier loop.
- Single- vs. Multi-Agent Ablation: Multi-agent configurations generally outperform single-agent configurations, but single-agent MiroFlow performs better on GAIA.The authors associate this exception with GAIA’s strongly sequential task structure and the risk of mistake propagation across sub-agents.
- Max Turns: Accuracy improves as the maximum number of turns increases and then saturates, with higher-difficulty tasks more sensitive to the turn limit.Multi-agent systems converge faster, while the figure passage reports slightly worse saturation performance than the single-agent setting.
- Toolset Robustness: MiroFlow maintains comparable performance with open-source and default toolsets on GAIA-Val and GAIA-Val-Text.This demonstrates robustness across different tool configurations.
- I/O Processing: Post-hoc output processing drives most I/O-processing gains, while input processing provides smaller stabilizing effects.The mechanisms improve reasoning accuracy by enforcing structured generation and adherence to task specifications.
5. Conclusion
MiroFlow combines a hierarchical agent architecture with flexible orchestration, robust execution, and optional heavy reasoning. Across multiple benchmarks, it achieves reproducible state-of-the-art performance without task-specific tuning and generalizes across heterogeneous environments.
- Conclusion: MiroFlow integrates a hierarchical agent architecture, an agent graph, a robust workflow, and an optional heavy-reasoning mode.These components target flexibility, robustness, reproducibility, and performance in complex deep-research scenarios.
- Conclusion: MiroFlow achieves reproducible state-of-the-art performance across multiple benchmarks without task-specific tuning.The framework generalizes reliably across heterogeneous environments.
- Conclusion: The ablation studies provide insights for advancing agent-system design and position MiroFlow as a foundation for future agent research and development.The stated scope includes more accessible, scalable, and trustworthy agent-based intelligence.
A. Empirical Examples of Instability in Agent Systems
Agent instability arises from instruction and output non-adherence, variable search and network conditions, and misinterpretation of tool errors. These failures can cause abandoned searches, hallucinated answers, or incorrect results.
- Instruction and output non-adherence causes logical inversions, altered text, and malformed outputs that violate task requirements.Examples include selecting West-facing fronts instead of backs, changing “fresh basil” to “basil,” and producing an overly long JSON block.
- Agents may misinterpret tool or syntax errors as data problems, abandon the task, and hallucinate answers instead of correcting tool usage.The examples include a missing sandbox path causing FileNotFound and a missed closing tool tag causing a syntax error.
- Connection failures can block required data access and force agents to rely on incomplete text descriptions instead of visual verification.The cited example involves DNS and 403 Forbidden failures preventing access to a required image.
- Search-result randomness can make a task unsolvable when the retrieved document lacks required information.One retrieved version contained only 28 references although the ground truth required Reference #29.
B. Framework Comparison on Flexibility and Stability
The comparison evaluates agent frameworks by architectural flexibility and reproducibility-oriented stability. Reproduction attempts for OWL and AgentOrchestra yielded lower scores than originally reported, underscoring practical reproducibility difficulties.
- Framework flexibility is assessed from agent-architecture complexity, with Graph denoting dynamic and adaptive workflows across diverse tasks.Single-Agent and Multi-Agent identify conventional architectures, while Graph indicates general frameworks supporting dynamic agent graphs.
- Framework stability is assessed through reproducibility effort and performance variance, with Poor, Fair, and Good representing increasing robustness.The table defines Poor as difficult to reproduce, Fair as reproducible under maintained environments, and Good as enhanced by special robustness designs.
- Reproduced OWL and AgentOrchestra scores were lower than originally reported despite following available instructions and retrying network connections.The authors state that this does not necessarily invalidate the original claims but indicates limited reproducibility and robustness.
C. Multi-Agent Performance Degradation on GAIA
Multi-agent systems generally perform better across the evaluated benchmarks, but GAIA-Val favors the single-agent model. The authors associate this discrepancy with GAIA’s strongly sequential task structure and the risks of cross-agent information loss.
- The multi-agent setup generally yields higher performance, whereas the single-agent model achieves superior results on GAIA-Val.The evaluation covers GAIA-Val, BrowseComp-200, and HLE-200.
- GAIA’s strongly sequential task structure increases the risk of information loss or mistake propagation when work is decomposed across agents.The comparison contrasts multi-agent decomposition with a continuous single-agent reasoning trajectory.
- A single agent preserves more stable global context, which is especially important for multimodal tasks.The cited example attributes an error to a low-resolution image and highlights the value of comprehensive contextual awareness.
D. Agent Graph
MiroFlow replaces fixed single-agent or main-subagent structures with a directed agent graph that supports dynamic interaction, specialization, and scalable workflow composition. The framework is illustrated across video generation, travel planning, and job-application tasks.
- Traditional architectures: Single-agent architectures repeatedly call one agent’s strategies and tools but offer limited flexibility for complex or dynamic tasks.The baseline lacks role decomposition and specialized subagents, limiting modular expertise and parallel processing.
- Traditional architectures: Multi-agent architectures improve decomposition, specialization, parallel processing, and execution efficiency through a main agent and multiple sub-agents.However, the described baseline remains insufficiently flexible.
- Agent Graph: The agent graph enables agents to interact through a directed network rather than a single-agent or simple main-subordinate structure.Agents can dynamically call one another according to task requirements and exchange information across the graph.
- Agent Graph: New nodes or graph adjustments can extend functionality without redesigning the entire framework, supporting diverse application workflows.Examples cover short-video generation, complex travel planning, and job-application material generation.
E. Ablation on Context Length
MiroFlow’s performance improves as maximum context length increases, with notable gains around 24k–48k tokens before improvements begin to saturate. Longer contexts matter most for harder L3 tasks.
- Context lengths up to 400k tokens were evaluated on GAIA validation with GPT-5 in a single-agent configuration.The settings correspond to GPT-5’s maximum input capacity.
- Accuracy rises notably when context increases from short settings such as 8k to the 24k–48k range.Short contexts constrain retention of intermediate reasoning steps, producing incomplete or inconsistent solutions.
- Beyond 24k–48k tokens, extending context produces gradually smaller gains, including only marginal improvements at 400k tokens.
- Harder L3 tasks benefit most from additional context because they depend more heavily on long-range reasoning.
F. Agent Prompts
The agent prompts define a structured tool-use protocol based on XML-style tags and JSON arguments. They also prescribe iterative task decomposition, one tool call per response, and strict communication rules.
- Tool-Use Formatting Instructions: The MCP connects to servers that provide tools and resources, with each server potentially exposing multiple tools with defined input schemas.
- Tool-Use Formatting Instructions: Tool requests use XML-style tags containing a server name, tool name, and JSON-formatted arguments.The arguments must follow the tool’s input schema, with escaped quotes where needed.
- Tool-Use Formatting Instructions: String and scalar parameters are written directly, while lists and objects use JSON formatting.Spaces in string values are preserved, and parsing uses regular expressions rather than requiring valid XML.
- Agent Workflow: Tasks are handled iteratively by decomposing the request into ordered sub-goals and working through them sequentially.The prompt requests a concise numbered plan before action and review after each step.
- Tool-Use Communication Rules: Each response permits exactly one tool call unless the task is already solved, followed by stopping until the next user-provided result.The instructions also prohibit continuing analysis, issuing additional calls, or presenting the final answer prematurely.