Rethinking Multi-Agent Collaboration: When More Is Less

频道: arXiv
原文: https://arxiv.org/abs/2609.19759
原文语言: en
统计: 共 90 轮

[¶1]

Yishuo Yuan¹, Yibo Wu¹, Yihan Zhang², Minyuan Sun¹, Shenliang Li¹, Xinkai Ma¹, Yifan Li¹, Jiaheng Liu¹†

¹ Nanjing University ² Shanghai Jiao Tong University († Corresponding Author: liujiaheng@nju.edu.cn)

Abstract

Yishuo Yuan¹, Yibo Wu¹, Yihan Zhang², Minyuan Sun¹, Shenliang Li¹, Xinkai Ma¹, Yifan Li¹, Jiaheng Liu¹†

¹ 南京大学 ² 上海交通大学（† 通讯作者：liujiaheng@nju.edu.cn）

摘要

[¶2]

The rapid advancement of large language models and single-agent harnesses has reshaped the landscape of autonomous systems, raising a critical question of when multi-agent collaboration offers genuine value. As individual agent capabilities continue to scale, multi-agent collaboration faces diminishing returns while incurring growing context overhead. Through systematic analysis, we delineate the capability boundaries of multi-agent collaboration relative to single-agent alternatives, showing that it confers systematic benefits specifically in long-horizon tasks with sparse dependencies, while single-agent harnesses remain superior in tightly coupled, sequential workflows. Building on these insights, we propose SAIGE, a lightweight multi-agent collaboration mechanism based on Semantic-Aware Incremental Graph Evolution. SAIGE models collaboration as a dynamically evolving graph, where nodes are agent instances spawned on demand and edges encode semantic dependencies established through content-based information retrieval. Experiments on long-horizon, complex task benchmarks show that SAIGE achieves a favorable trade-off between context efficiency and task performance, and that scaling the agent pool or deepening the recursion level does not consistently improve outcomes. Our findings suggest that multi-agent superiority is bounded by task structure rather than universal, and that more agents do not necessarily make a system more intelligent.

大语言模型与单智能体 harness（外壳/运行框架）的快速发展重塑了自主系统的格局，也由此引出一个关键问题：多智能体协作（multi-agent collaboration）究竟在何时才能带来真正的价值。随着单个智能体（agent）的能力持续提升，多智能体协作的收益日趋递减，同时还要承担不断增长的上下文开销。通过系统性分析，我们刻画了多智能体协作相对于单智能体（single-agent）方案的能力边界，并表明其系统性收益集中体现在具有稀疏依赖（sparse dependencies）的长程（long-horizon）任务中；而在紧耦合（tightly coupled）的顺序式工作流中，单智能体 harness 依然更具优势。基于上述洞见，我们提出了 SAIGE，这是一种基于语义感知增量图演化（Semantic-Aware Incremental Graph Evolution）的轻量级多智能体协作机制。SAIGE 将协作建模为一张动态演化的图：节点是按需生成的智能体实例，边则编码了借助基于内容的信息检索所建立的语义依赖。在长程复杂任务基准上的实验表明，SAIGE 在上下文效率与任务性能之间取得了良好的权衡，而扩大智能体池（agent pool）或加深递归层级并不能稳定地改善结果。我们的发现表明，多智能体的优势受限于任务结构，而非普遍成立；更多的智能体并不必然让系统更智能。

[¶3]

1 Introduction

The rapid advancement of large language models (LLMs) has fundamentally reshaped the landscape of autonomous systems. As foundation models grow increasingly capable of handling long-horizon, complex tasks, the accompanying agent harnesses, such as Claude Code (Anthropic, 2025), Codex (OpenAI, 2025a), and DeepSeek Harness (DeepSeek, 2026a), have matured into highly sophisticated infrastructures. These single-agent systems now deliver robust, end-to-end execution in real-world scenarios, setting a formidable baseline for autonomy. In stark contrast, generic multi-agent collaboration frameworks often remain toy-level in practice, lingering on simplistic benchmarks (Paech, 2024; Wang et al., 2024b; Peng et al., 2024) and marginal performance gains (Yun et al., 2026; Alzu’bi et al., 2026). This widening gap compels a critical reexamination of when and why multi-agent collaboration offers genuine value over a well-equipped single-agent harness.

1 引言

大语言模型（LLM）的快速发展从根本上重塑了自主系统的格局。随着基础模型处理长程复杂任务的能力日益增强，与之配套的智能体 harness，如 Claude Code (Anthropic, 2025)、Codex (OpenAI, 2025a) 和 DeepSeek Harness (DeepSeek, 2026a)，已经发展为高度成熟的基础设施。这些单智能体系统如今已能在真实场景中实现稳健的端到端执行，为自主性树立了一条强劲的基线。与之形成鲜明对比的是，通用的多智能体协作框架在实践中往往仍停留在玩具级别，局限于过于简单的基准测试 (Paech, 2024; Wang et al., 2024b; Peng et al., 2024) 和微弱的性能提升 (Yun et al., 2026; Alzu’bi et al., 2026)。这一日益扩大的差距迫使我们审慎地重新审视：相较于一个配备完善的单智能体 harness，多智能体协作究竟在何时、又为何能够提供真正的价值。

[¶4]

Existing work often attributes the primary advantage of multi-agent systems to context isolation, which partitions a task to prevent context pollution and context rot (Huang et al., 2026; Hong et al., 2025). While intuitively appealing, this explanation remains largely qualitative and lacks a rigorous theoretical foundation. In this work, we aim to delineate the capability boundaries of multi-agent collaboration through graph theory. We formalize multi-agent collaboration by modeling task trajectories as dependency graphs, where subtasks are partitioned by bridge edges. This formalism reveals that multi-agent collaboration is not a universal panacea. Instead, it confers systematic benefits specifically in long-horizon tasks with sparse dependencies, where context isolation can be exploited without incurring prohibitive coordination overhead. Conversely, in tightly coupled, sequential workflows, single-agent harnesses remain superior.

现有工作通常将多智能体系统的主要优势归因于上下文隔离（context isolation），即通过切分任务来防止上下文污染（context pollution）与上下文腐化（context rot）(Huang et al., 2026; Hong et al., 2025)。这一解释虽然在直觉上颇具吸引力，但在很大程度上仍停留于定性层面，缺乏严谨的理论基础。在本文中，我们旨在借助图论来刻画多智能体协作的能力边界。我们将任务轨迹（trajectory）建模为依赖图，其中子任务（subtask）由桥边（bridge edge）划分，从而对多智能体协作进行形式化。这一形式化揭示出，多智能体协作并非放之四海而皆准的万能药。相反，其系统性收益集中体现在具有稀疏依赖的长程任务中——在这类任务里，可以充分利用上下文隔离，而不致招致难以承受的协调开销。反之，在紧耦合的顺序式工作流中，单智能体 harness 依然更具优势。

[¶5]

Building on these theoretical insights, we propose SAIGE (Semantic-Aware Incremental Graph Evolution), an elegant and general multi-agent collaboration mechanism. SAIGE models collaboration as a dynamically evolving graph, where nodes are agent instances spawned on demand and edges encode semantic dependencies established through content-based information retrieval. Rather than committing to a static topology upfront, SAIGE grows the subtask tree incrementally as execution unfolds, grounding orchestration decisions in actual execution feedback. We empirically validate our framework on long-horizon, complex task benchmarks, showing that SAIGE achieves a favorable trade-off between context efficiency and task performance compared to existing generic multi-agent methods. Notably, our ablation study indicates that neither a larger agent pool nor a deeper recursion hierarchy consistently improves performance, suggesting that more agents do not necessarily make a system more intelligent. Our findings offer a principled understanding of when collaboration provides meaningful advantage over single-agent execution, and suggest that indiscriminate multi-agent scaling warrants reconsideration.

基于上述理论洞见，我们提出了 SAIGE（Semantic-Aware Incremental Graph Evolution，语义感知增量图演化），一种优雅且通用的多智能体协作机制。SAIGE 将协作建模为一张动态演化的图：节点是按需生成的智能体实例，边则编码了借助基于内容的信息检索所建立的语义依赖。SAIGE 并不预先固定一个静态拓扑，而是随着执行的展开增量式地生长子任务树，使编排（orchestration）决策立足于真实的执行反馈。我们在长程复杂任务基准上对该框架进行了实证验证，结果表明：与现有的通用多智能体方法相比，SAIGE 在上下文效率与任务性能之间取得了更优的权衡。值得注意的是，我们的消融研究表明，无论是扩大智能体池还是加深递归层级，都不能稳定地提升性能，这说明更多的智能体并不必然让系统更智能。我们的发现从原理上阐明了协作在何时能比单智能体执行带来实质性优势，并提示：不加区分地扩展多智能体规模的做法值得重新考量。

[¶6]

2 Related Work

2 相关工作

[¶7]

2.1 Multi-Agent Collaboration

Multi-agent collaboration governs how agents coordinate, communicate, and align behaviors toward shared objectives, evolving from rigid predefined structures to adaptive, context-aware interactions. Role allocation ranges from static, pre-assigned responsibilities (Chen et al., 2025; Fei et al., 2026) to dynamic selection or runtime instantiation based on task demands (Wu et al., 2023; Chen et al., 2023; Alzu’bi et al., 2026). Communication likewise spans explicit message passing via structured documents or natural language (Hong et al., 2024; Wang et al., 2025c; Mou et al., 2025) and implicit inference from environmental cues (Park et al., 2023; Zou et al., 2026). Information flow further structures these interactions as sequential pipelines or parallel exploration (Shen et al., 2023; Wang et al., 2024a), while interaction patterns ultimately manifest as cooperative or competitive dynamics (Yang et al., 2026; Fu et al., 2023).

2.1 多智能体协作

多智能体协作决定了智能体如何围绕共同目标进行协调、通信并对齐各自的行为，其形态已从僵化的预定义结构演进为自适应、具备上下文感知能力的交互。在角色分配方面，既有静态、预先指派的职责 (Chen et al., 2025; Fei et al., 2026)，也有依据任务需求进行的动态选择或运行时实例化 (Wu et al., 2023; Chen et al., 2023; Alzu’bi et al., 2026)。通信方式同样涵盖两类：一是借助结构化文档或自然语言进行的显式消息传递 (Hong et al., 2024; Wang et al., 2025c; Mou et al., 2025)，二是基于环境线索的隐式推断 (Park et al., 2023; Zou et al., 2026)。信息流进一步将这些交互组织为顺序流水线或并行探索 (Shen et al., 2023; Wang et al., 2024a)，而交互模式最终体现为合作或竞争的动态关系 (Yang et al., 2026; Fu et al., 2023)。

[¶8]

2.2 Multi-Agent Topology

Multi-agent topology serves as a critical structural framework for governing agent execution, communication, and interactions. While early attempts often embedded structural organization implicitly (Chan et al., 2023; Wu et al., 2023; Khattab et al., 2023), recent practices have explicitly represented multi-agent organizations as graphs (Liu et al., 2024; Zhuge et al., 2024; Qian et al., 2025). These topologies generally fall into three representative paradigms: centralized, distributed, and hybrid. Centralized topologies leverage a global coordinator for information aggregation and routing (Zhang et al., 2026a; Li et al., 2025); distributed topologies employ peer-to-peer communication and localized routing (Yang et al., 2025; Wang et al., 2025a) to enhance autonomy and scalability; and hybrid topologies combine centralized strategic planning with decentralized execution (Qian et al., 2024; Hong et al., 2024; Zhang et al., 2026b). Concretely, these orchestration strategies manifest as distinct structural morphologies, including chain (Qian et al., 2024; Hong et al., 2024; Holt et al., 2025), star (Wu et al., 2023; Yan et al., 2024), tree (Ishibashi and Nishimura, 2024), and general graph topologies (Qian et al., 2025; Yun et al., 2026).

2.2 多智能体拓扑

多智能体拓扑是调控智能体执行、通信与交互的关键结构框架。早期尝试往往将结构组织隐式地内嵌于系统之中 (Chan et al., 2023; Wu et al., 2023; Khattab et al., 2023)，而近期的实践则将多智能体组织显式地表示为图 (Liu et al., 2024; Zhuge et al., 2024; Qian et al., 2025)。这些拓扑大体可归为三种代表性范式：集中式、分布式与混合式。集中式拓扑借助全局协调者进行信息汇聚与路由 (Zhang et al., 2026a; Li et al., 2025)；分布式拓扑采用点对点通信与局部路由 (Yang et al., 2025; Wang et al., 2025a)，以增强自主性与可扩展性；混合式拓扑则将集中式的战略规划与去中心化的执行相结合 (Qian et al., 2024; Hong et al., 2024; Zhang et al., 2026b)。具体而言，这些编排策略体现为各不相同的结构形态，包括链式 (Qian et al., 2024; Hong et al., 2024; Holt et al., 2025)、星形 (Wu et al., 2023; Yan et al., 2024)、树形 (Ishibashi and Nishimura, 2024) 以及一般图拓扑 (Qian et al., 2025; Yun et al., 2026)。

[¶9]

3 Formalizing Multi-Agent Collaboration

What is the core of multi-agent collaboration, and under what idealized conditions does it genuinely help? We take a deliberately idealized route: we ask what multi-agent collaboration is fundamentally doing to a task, and derive its benefit from that answer, leaving the gap between the idealized and the practical as a source of empirically testable predictions rather than a hidden assumption.

3 多智能体协作的形式化

多智能体协作的核心是什么？它又在何种理想化条件下才真正有益？我们有意选择一条理想化的路线：先追问多智能体协作从根本上对任务做了什么，再由这一答案推导出其收益；至于理想与实际之间的差距，我们不将其视为隐含假设，而是将其作为可供实证检验的预测的来源。

[¶10]

3.1 Preliminaries

3.1 预备知识

[¶11]

3.1.1 Trajectory as a Dependency Directed Acyclic Graph

Consider a task trajectory of length T: \tau=\{x_{1},x_{2},\ldots,x_{T}\}, where each x_{t}=(o_{t},a_{t}) denotes the interaction tuple at step t, consisting of the new observation o_{t} received and the action a_{t} taken by the agent. Let \mathcal{H}_{t}=\{x_{1},\ldots,x_{t-1}\} denote the historical context available before generating x_{t}. This history grows monotonically with t, and the agent’s decisions may depend on arbitrary subsets of this history.

To characterize these dependencies formally, we define a value function Q_{t}(a_{t}\mid o_{t},\mathcal{H}_{t}) that represents the expected return of taking action a_{t} given historical context \mathcal{H}_{t}. For any pair of nodes x_{i},x_{t}\in\tau with i<t, we say that x_{t} has a direct dependency on x_{i} if removing the interaction tuple x_{i} from the historical context causes a significant drop in the action value at step t:

3.1.1 将轨迹视为依赖有向无环图

考虑一条长度为 T 的任务轨迹：\tau=\{x_{1},x_{2},\ldots,x_{T}\}，其中每个 x_{t}=(o_{t},a_{t}) 表示第 t 步的交互元组，由智能体接收到的新观测 o_{t} 与其采取的动作 a_{t} 组成。令 \mathcal{H}_{t}=\{x_{1},\ldots,x_{t-1}\} 表示生成 x_{t} 之前可用的历史上下文。这一历史随 t 单调增长，而智能体的决策可能依赖于该历史的任意子集。

为了形式化地刻画这些依赖关系，我们定义价值函数（value function）Q_{t}(a_{t}\mid o_{t},\mathcal{H}_{t})，表示在给定历史上下文 \mathcal{H}_{t} 时采取动作 a_{t} 的期望回报。对于任意一对满足 i<t 的节点 x_{i},x_{t}\in\tau，若从历史上下文中移除交互元组 x_{i} 会导致第 t 步的动作价值显著下降，则称 x_{t} 直接依赖于 x_{i}：

[¶12]

(x_{i},x_{t})\in\mathcal{E}\iff Q_{t}(a_{t}\mid o_{t},\mathcal{H}_{t}\setminus\{x_{i}\})<Q_{t}(a_{t}\mid o_{t},\mathcal{H}_{t})-\delta,   (1)

where \mathcal{H}_{t}\setminus\{x_{i}\} denotes the historical context with the contribution of x_{i} removed, and \delta>0 is a predefined threshold. Since all edges point forward in time, the trajectory naturally induces a directed acyclic graph \mathcal{G}=(\mathcal{V},\mathcal{E}), with node set \mathcal{V}=\tau. Each directed edge (x_{i},x_{t})\in\mathcal{E}\subseteq\mathcal{V}\times\mathcal{V} indicates that node x_{t} directly depends on node x_{i}.

We further assume that a task trajectory contains no redundant interactions. Specifically, every node in the trajectory contributes to at least one subsequent decision, implying that each node has out-degree at least one in the dependency graph, with the terminal node serving as the unique sink. Under this assumption, the induced DAG \mathcal{G} is weakly connected. This assumption is mild in practice, as interactions that do not influence any future step can be discarded from the trajectory without affecting the task outcome.

(x_{i},x_{t})\in\mathcal{E}\iff Q_{t}(a_{t}\mid o_{t},\mathcal{H}_{t}\setminus\{x_{i}\})<Q_{t}(a_{t}\mid o_{t},\mathcal{H}_{t})-\delta,   (1)

其中 \mathcal{H}_{t}\setminus\{x_{i}\} 表示移除 x_{i} 的贡献之后的历史上下文，\delta>0 为预先设定的阈值。由于所有边都指向时间上更靠后的节点，该轨迹自然诱导出一个有向无环图（DAG）\mathcal{G}=(\mathcal{V},\mathcal{E})，其节点集为 \mathcal{V}=\tau。每条有向边 (x_{i},x_{t})\in\mathcal{E}\subseteq\mathcal{V}\times\mathcal{V} 都表示节点 x_{t} 直接依赖于节点 x_{i}。

我们进一步假设任务轨迹中不包含冗余交互。具体而言，轨迹中的每个节点都至少对一个后续决策有所贡献，这意味着在依赖图中每个节点的出度（out-degree）至少为 1，而终止节点则是唯一的汇点（sink）。在这一假设下，所诱导的 DAG \mathcal{G} 是弱连通的。该假设在实践中是温和的，因为不影响任何后续步骤的交互可以从轨迹中剔除，而不会影响任务结果。

[¶13]

[Figure 1: Overview of the theoretical framework for multi-agent collaboration.]

[图 1：多智能体协作理论框架概览。]

[¶14]

3.1.2 Decomposing Trajectories into Subtasks via Bridge Edges

Within the DAG \mathcal{G}, certain edges serve as critical information channels connecting distinct regions of the graph. An edge (x_{i},x_{t})\in\mathcal{E} is a bridge edge if its removal increases the number of weakly connected components of \mathcal{G}.

Let \mathcal{E}^{*}\subseteq\mathcal{E} denote the set of all bridge edges. Removing all bridge edges from \mathcal{G} decomposes the graph into m weakly connected components \mathcal{G}\setminus\mathcal{E}^{*}=\mathcal{C}_{1}\cup\cdots\cup\mathcal{C}_{m}. The corresponding subtask trajectory is defined as the ordered sequence of nodes in \mathcal{C}_{k}: \tau_{(k)}=\{x_{n_{1}},x_{n_{2}},\ldots,x_{n_{T_{k}}}\}\subseteq\tau, where T_{k}=|\mathcal{C}_{k}|, and the subtask trajectories collectively partition the original trajectory: \tau=\tau_{(1)}\cup\tau_{(2)}\cup\cdots\cup\tau_{(m)}.

3.1.2 通过桥边将轨迹分解为子任务

在 DAG \mathcal{G} 中，某些边充当着连接图中不同区域的关键信息通道。对于边 (x_{i},x_{t})\in\mathcal{E}，若将其删除会使 \mathcal{G} 的弱连通分量（weakly connected component）数量增加，则称其为桥边（bridge edge）。

令 \mathcal{E}^{*}\subseteq\mathcal{E} 表示所有桥边构成的集合。从 \mathcal{G} 中删除全部桥边后，该图被分解为 m 个弱连通分量 \mathcal{G}\setminus\mathcal{E}^{*}=\mathcal{C}_{1}\cup\cdots\cup\mathcal{C}_{m}。相应的子任务轨迹定义为 \mathcal{C}_{k} 中节点的有序序列：\tau_{(k)}=\{x_{n_{1}},x_{n_{2}},\ldots,x_{n_{T_{k}}}\}\subseteq\tau，其中 T_{k}=|\mathcal{C}_{k}|；各子任务轨迹共同构成原轨迹的一个划分：\tau=\tau_{(1)}\cup\tau_{(2)}\cup\cdots\cup\tau_{(m)}。

[¶15]

In multi-agent systems, this decomposition has a natural interpretation: each subtask \tau_{(k)} is assigned to an individual agent responsible for executing that segment of the trajectory. The bridge edges between components correspond to communication channels between the respective agents, enabling information flow across subtask boundaries when necessary.

Let \mathcal{V}_{\mathcal{S}}=\{\tau_{(1)},\tau_{(2)},\ldots,\tau_{(m)}\} denote the set of subtask trajectories. The directed edges between subtasks are induced by the bridge edges \mathcal{E}^{*}. Since each bridge edge connects nodes from different components, this yields a well-defined relation:

在多智能体系统中，这一分解有着自然的解释：每个子任务 \tau_{(k)} 被分配给一个独立的智能体，由它负责执行该段轨迹。分量之间的桥边对应于相应智能体之间的通信通道，使信息能够在必要时跨越子任务边界流动。

令 \mathcal{V}_{\mathcal{S}}=\{\tau_{(1)},\tau_{(2)},\ldots,\tau_{(m)}\} 表示子任务轨迹的集合。子任务之间的有向边由桥边 \mathcal{E}^{*} 诱导而来。由于每条桥边连接的都是来自不同分量的节点，由此可得一个良定义的关系：

[¶16]

(\tau_{(p)},\tau_{(q)})\in\mathcal{E}_{\mathcal{S}}\iff\exists(x_{p},x_{q})\in\mathcal{E}^{*}\text{ such that }x_{p}\in\tau_{(p)}\text{ and }x_{q}\in\tau_{(q)}.   (2)

The pair \mathcal{T}=(\mathcal{V}_{\mathcal{S}},\mathcal{E}_{\mathcal{S}}) forms a subtask tree that captures information flow at the granularity of subtasks.

(\tau_{(p)},\tau_{(q)})\in\mathcal{E}_{\mathcal{S}}\iff\exists(x_{p},x_{q})\in\mathcal{E}^{*}\text{ such that }x_{p}\in\tau_{(p)}\text{ and }x_{q}\in\tau_{(q)}.   (2)

二元组 \mathcal{T}=(\mathcal{V}_{\mathcal{S}},\mathcal{E}_{\mathcal{S}}) 构成一棵子任务树（subtask tree），它在子任务的粒度上刻画信息流。

[¶17]

3.1.3 Context Cost Reduction

Let c(x) denote the non-negative computational overhead of including interaction tuple x in the historical context. For a subtask trajectory \tau_{(k)}=\{x_{n_{1}},\ldots,x_{n_{T_{k}}}\}, let \mathcal{B}_{k}\subseteq\mathcal{E}^{*} denote the set of bridge edges that enter \tau_{(k)}, i.e., \mathcal{B}_{k}=\{(x_{p},x_{q})\in\mathcal{E}^{*}\mid x_{q}\in\tau_{(k)}\}. Let \operatorname{idx}(x,\tau) denote the index of node x within trajectory \tau. The total context cost of executing subtask \tau_{(k)} is decomposed as

C(\tau_{(k)})=C_{I}(\tau_{(k)})+C_{E}(\tau_{(k)})=\sum_{t=1}^{T_{k}}\sum_{i=1}^{t-1}c(x_{n_{i}})+\sum_{(x_{p},x_{q})\in\mathcal{B}_{k}}\sum_{i=\operatorname{idx}(x_{q},\tau_{(k)})}^{T_{k}}c(x_{p}),   (3)

3.1.3 上下文成本的降低

令 c(x) 表示将交互元组 x 纳入历史上下文所带来的非负计算开销。对于子任务轨迹 \tau_{(k)}=\{x_{n_{1}},\ldots,x_{n_{T_{k}}}\}，令 \mathcal{B}_{k}\subseteq\mathcal{E}^{*} 表示进入 \tau_{(k)} 的桥边集合，即 \mathcal{B}_{k}=\{(x_{p},x_{q})\in\mathcal{E}^{*}\mid x_{q}\in\tau_{(k)}\}. 再令 \operatorname{idx}(x,\tau) 表示节点 x 在轨迹 \tau 中的索引。执行子任务 \tau_{(k)} 的总上下文成本可分解为

C(\tau_{(k)})=C_{I}(\tau_{(k)})+C_{E}(\tau_{(k)})=\sum_{t=1}^{T_{k}}\sum_{i=1}^{t-1}c(x_{n_{i}})+\sum_{(x_{p},x_{q})\in\mathcal{B}_{k}}\sum_{i=\operatorname{idx}(x_{q},\tau_{(k)})}^{T_{k}}c(x_{p}),   (3)

[¶18]

where C_{I}(\tau_{(k)}) accounts for the cost of accumulating historical context from nodes within the same subtask, and C_{E}(\tau_{(k)}) accounts for the cost of pulling context x_{p} from predecessor subtasks via incoming bridge edges, starting from the position of the target node x_{q} through all subsequent steps.

For the original monolithic trajectory \tau, there are no incoming bridge edges, so \mathcal{B}=\varnothing, and the cost is simply:

C(\tau)=\sum_{t=1}^{T}\sum_{i=1}^{t-1}c(x_{i}).   (4)

Our key claim is that, under idealized conditions where the complete task trajectory is known in advance, decomposing the trajectory into subtasks reduces the total context cost. The core of the proof is the following lemma, which shows that partitioning a trajectory along a single bridge edge does not increase the total context cost. The detailed proof of Lemma 1 is deferred to Appendix A.

其中，C_{I}(\tau_{(k)}) 表示在同一子任务内部、由各节点累积历史上下文所产生的成本；C_{E}(\tau_{(k)}) 表示经由入向桥边从前驱子任务拉取上下文 x_{p} 所产生的成本，该成本从目标节点 x_{q} 所在的位置开始计入，并贯穿其后的所有步骤。

对于原始的整体式轨迹 \tau，不存在入向桥边，即 \mathcal{B}=\varnothing，其成本便简化为：

C(\tau)=\sum_{t=1}^{T}\sum_{i=1}^{t-1}c(x_{i}).   (4)

我们的核心论断是：在完整任务轨迹可事先获知的理想化条件下，将轨迹分解为子任务能够降低总上下文成本。证明（proof）的核心是下面这条引理（lemma），它表明：沿单条桥边切分一条轨迹，不会增加总上下文成本。引理 1 的详细证明见附录 A。

[¶19]

Lemma 1. For any trajectory \tau_{(S)}=\tau_{(L)}\cup\tau_{(R)} partitioned into two subtask trajectories by a single bridge edge (x_{L},x_{R}) with x_{L}\in\tau_{(L)} and x_{R}\in\tau_{(R)}, the sum of the context costs of the two subtask trajectories is no greater than the cost of the original trajectory:

C(\tau_{(L)})+C(\tau_{(R)})\leq C(\tau_{(S)}).

Recursively applying Lemma 1 to \tau_{(L)} and \tau_{(R)} yields:

C(\tau)\geq C(\tau_{(L)})+C(\tau_{(R)})\geq\cdots\geq\sum_{k=1}^{m}C(\tau_{(k)}).

This establishes that, when the task trajectory is known and the decomposition is performed correctly, multi-agent decomposition reduces context cost. It should be noted that this analysis does not account for context compression or other mitigation strategies that may alter the cost structure.

引理 1. 对于任意一条轨迹 \tau_{(S)}=\tau_{(L)}\cup\tau_{(R)}，若它被单条桥边 (x_{L},x_{R}) 切分为两条子任务轨迹，其中 x_{L}\in\tau_{(L)} 且 x_{R}\in\tau_{(R)}，则这两条子任务轨迹的上下文成本之和不超过原轨迹的成本：

C(\tau_{(L)})+C(\tau_{(R)})\leq C(\tau_{(S)}).

对 \tau_{(L)} 和 \tau_{(R)} 递归地应用引理 1，可得：

C(\tau)\geq C(\tau_{(L)})+C(\tau_{(R)})\geq\cdots\geq\sum_{k=1}^{m}C(\tau_{(k)}).

由此可以确立：当任务轨迹已知且分解执行正确时，多智能体分解能够降低上下文成本。需要指出的是，这一分析并未考虑上下文压缩或其他可能改变成本结构的缓解策略。

[¶20]

3.1.4 Orchestration as Bridge Edge Prediction

The decomposition above is post-hoc: it presumes complete knowledge of the entire trajectory \tau and its dependency structure. In practice, the trajectory unfolds sequentially, and the DAG \mathcal{G} is not known in advance. The objective of multi-agent orchestration is therefore to predict the bridge edges \mathcal{E}^{*} before or during execution, without access to the complete trajectory.

Let \mathcal{E}^{*} denote the true set of bridge edges induced by the full trajectory, and let \hat{\mathcal{E}}_{t} be the set of bridge edges predicted by the orchestration strategy at time t based on the observed prefix \tau_{<t}. Since the true bridge edges \mathcal{E}^{*} are only revealed after the entire trajectory is complete, the prediction \hat{\mathcal{E}}_{t} concerns edges that lie in the future, i.e., edges e_{i\to j} with j>t. The orchestration problem is to minimize the expected discrepancy between the true and predicted bridge edge sets:

3.1.4 编排即桥边预测

上述分解是事后（post-hoc）的：它预设已完整掌握整条轨迹 \tau 及其依赖结构。而在实践中，轨迹是按顺序逐步展开的，DAG \mathcal{G} 也无法事先获知。因此，多智能体编排的目标，是在无法获得完整轨迹的情况下，于执行之前或执行过程中预测出桥边 \mathcal{E}^{*}。

令 \mathcal{E}^{*} 表示由完整轨迹导出的真实桥边集合，\hat{\mathcal{E}}_{t} 表示编排策略在时刻 t 基于已观测前缀 \tau_{<t} 预测出的桥边集合。由于真实桥边 \mathcal{E}^{*} 只有在整条轨迹完成之后才会显现，预测 \hat{\mathcal{E}}_{t} 所针对的是位于未来的边，即满足 j>t 的边 e_{i\to j}。编排问题就是要最小化真实桥边集合与预测桥边集合之间的期望差异：

[¶21]

\min_{\hat{\mathcal{E}}_{t}}\;\mathbb{E}\left[\mathcal{L}(\mathcal{E}^{*},\hat{\mathcal{E}}_{t})\mid\tau_{<t}\right],   (5)

where \mathcal{L} is a loss function that measures the dissimilarity between two sets of directed edges over \mathcal{V}. A correct prediction partitions the trajectory into the true subtasks; an incorrect prediction results in suboptimal decomposition and diminished context cost reduction.

\min_{\hat{\mathcal{E}}_{t}}\;\mathbb{E}\left[\mathcal{L}(\mathcal{E}^{*},\hat{\mathcal{E}}_{t})\mid\tau_{<t}\right],   (5)

其中 \mathcal{L} 是一个损失函数，用于度量 \mathcal{V} 上两个有向边集合之间的差异。正确的预测会将轨迹切分为真实的子任务；错误的预测则会导致次优的分解，并削弱上下文成本的降幅。

[¶22]

3.2 Discussion

Our theoretical and empirical results jointly characterize when multi-agent collaboration helps and why its benefits are bounded.

When collaboration pays off. Multi-agent collaboration is effective precisely when a task admits relatively independent subtasks, so that each agent maintains a focused context window and excludes task-irrelevant information. A single-agent system, by contrast, must accumulate observations indiscriminately, degrading the signal-to-noise ratio and increasing the risk of erroneous execution. This benefit is contingent on the accuracy of bridge-edge prediction: a mispredicted edge can trap an agent in a local deadlock while awaiting a dependency that never materializes, or inflate communication overhead as agents recover from an erroneous partition.

3.2 讨论

我们的理论结果与实证结果共同刻画了多智能体协作在何时有益，以及其收益为何存在上限。

协作何时带来收益。恰恰是在任务能够拆分出相对独立的子任务时，多智能体协作才会奏效：此时每个智能体都能维持一个聚焦的上下文窗口，将与任务无关的信息排除在外。相比之下，单智能体系统只能不加区分地累积观测，这会降低信噪比，并增加执行出错的风险。这一收益取决于桥边预测的准确性：一条预测错误的边，既可能使某个智能体在等待一个永远不会出现的依赖时陷入局部死锁（local deadlock），也可能在智能体从错误划分中恢复时推高通信开销。

[¶23]

The cost of isolation. Context isolation localizes each agent’s working memory to its subtask, containing failures within the corresponding scope rather than letting them contaminate the global context. This mitigates the incomplete workflows and premature termination that plague single-agent execution on long-horizon tasks, at the cost of higher aggregate token consumption, since decomposition extends the overall workflow.

Why scaling does not help. Because each bridge edge is predicted from an observed prefix, prediction errors accumulate as the number of subtasks grows, while additional agents incur higher coordination costs in communication, synchronization, and conflict resolution. The marginal benefit of adding agents therefore diminishes, and may eventually be offset by accumulated errors and rising coordination overhead. This explains why more agents do not necessarily make a system more intelligent, and motivates a mechanism that grows its collaboration graph only where the task structure permits.

隔离的代价。上下文隔离将每个智能体的工作记忆局限于其所负责的子任务，使失败被控制在相应范围之内，而不会污染全局上下文。这缓解了长程任务中困扰单智能体执行的工作流不完整与过早终止问题，代价是总 token 消耗更高，因为分解会拉长整体工作流。

为何扩大规模无济于事。由于每条桥边都是根据已观测的前缀预测出来的，预测误差会随子任务数量的增加而累积；与此同时，新增的智能体还会在通信、同步与冲突消解上带来更高的协调成本。因此，增加智能体的边际收益会递减，最终甚至可能被累积的误差和不断攀升的协调开销所抵消。这解释了为什么更多的智能体并不一定让系统更智能，也促使我们设计一种仅在任务结构允许之处才扩展其协作图的机制。

[¶24]

4 Methodology

We propose Semantic-Aware Incremental Graph Evolution (SAIGE), a lightweight mechanism for decomposing tasks under trajectory uncertainty. Rather than predicting all bridge edges in advance, SAIGE evolves the subtask tree incrementally during execution, growing the structure only when semantic dependencies are revealed by execution feedback.

[Figure 2: SAIGE: incremental node generation via progressive subtask decomposition, and progressive edge resolution via on-demand message fetching.]

4 方法

我们提出语义感知增量图演化（Semantic-Aware Incremental Graph Evolution，SAIGE），这是一种在轨迹不确定的情况下分解任务的轻量级机制。SAIGE 并不预先预测所有桥边，而是在执行过程中增量地演化子任务树，只有当执行反馈揭示出语义依赖时才扩展这一结构。

[图 2：SAIGE：通过渐进式子任务分解实现增量节点生成，并通过按需消息拉取（message fetching）实现渐进式边解析。]

[¶25]

4.1 Incremental Node Generation

Bridge edges are inherently difficult to predict reliably at the outset, and premature commitment to a static topology risks compounding early mispredictions. Let \hat{\mathcal{E}}_{t-1} and \hat{\mathcal{E}}_{t} denote the predicted bridge-edge sets at consecutive steps, with \mathcal{E}^{*} the ground truth. Since SAIGE predicts incrementally, we have \hat{\mathcal{E}}_{t-1}\subseteq\hat{\mathcal{E}}_{t}, and

P(\hat{\mathcal{E}}_{t}\subseteq\mathcal{E}^{*}\mid\hat{\mathcal{E}}_{t-1}\subseteq\mathcal{E}^{*},\tau_{<t})=\frac{P(\hat{\mathcal{E}}_{t}\subseteq\mathcal{E}^{*}\mid\tau_{<t})}{P(\hat{\mathcal{E}}_{t-1}\subseteq\mathcal{E}^{*}\mid\tau_{<t})}\geq P(\hat{\mathcal{E}}_{t}\subseteq\mathcal{E}^{*}\mid\tau_{<t}),   (6)

4.1 增量节点生成

桥边本身就难以在一开始被可靠地预测，而过早锁定一个静态拓扑，则可能使早期的预测错误不断叠加。令 \hat{\mathcal{E}}_{t-1} 和 \hat{\mathcal{E}}_{t} 分别表示相邻两步预测出的桥边集合，\mathcal{E}^{*} 为真实值（ground truth）。由于 SAIGE 以增量方式进行预测，有 \hat{\mathcal{E}}_{t-1}\subseteq\hat{\mathcal{E}}_{t}，且

P(\hat{\mathcal{E}}_{t}\subseteq\mathcal{E}^{*}\mid\hat{\mathcal{E}}_{t-1}\subseteq\mathcal{E}^{*},\tau_{<t})=\frac{P(\hat{\mathcal{E}}_{t}\subseteq\mathcal{E}^{*}\mid\tau_{<t})}{P(\hat{\mathcal{E}}_{t-1}\subseteq\mathcal{E}^{*}\mid\tau_{<t})}\geq P(\hat{\mathcal{E}}_{t}\subseteq\mathcal{E}^{*}\mid\tau_{<t}),   (6)

[¶26]

which indicates that deferring edge prediction until execution evidence accumulates is more reliable than committing to a topology upfront.

Accordingly, SAIGE spawns subtask nodes on demand rather than pre-allocating them. A running agent delegates a child agent only when it detects a dependency boundary that satisfies the bridge-edge property, that is, a single-step dependency across which the subproblem can be executed independently given a bounded context summary. When such a boundary is present, the subproblem is delegated and the child agent executes autonomously with a self-contained instruction. When no such boundary is present, no child is spawned and the parent agent continues to execute the task monolithically. This conditional delegation is what allows SAIGE to avoid the decomposition penalty on densely coupled tasks.

这表明，把边预测推迟到执行证据积累之后，比一开始就锁定拓扑更为可靠。

据此，SAIGE 按需派生子任务节点，而不是预先分配。只有当正在运行的智能体检测到一个满足桥边性质的依赖边界时，它才会委派一个子智能体；这种边界即一条单步依赖，跨过它之后，只要给定一份有界的上下文摘要，子问题就能被独立执行。若存在这样的边界，子问题便被委派出去，由子智能体依据一条自包含的指令自主执行；若不存在这样的边界，则不派生子智能体，由父智能体继续以整体方式执行该任务。正是这种有条件的委派，使 SAIGE 能够在稠密耦合的任务上避开分解代价。

[¶27]

4.2 Progressive Edge Resolution

Edges between subtask nodes are established through progressive message fetching. Each agent writes its result upon completion and retrieves dependencies only when needed. Let \mathcal{B}_{k} denote the set of bridge edges entering subtask \tau_{(k)}, and let \operatorname{idx}(x_{q},\tau_{(k)}) denote the step at which dependency on x_{p} becomes active. Progressive fetching incurs cost

\sum_{(x_{p},x_{q})\in\mathcal{B}_{k}}\sum_{i=\operatorname{idx}(x_{q},\tau_{(k)})}^{T_{k}}c(x_{p})\leq\sum_{(x_{p},x_{q})\in\mathcal{B}_{k}}\sum_{i=1}^{T_{k}}c(x_{p}),   (7)

where the right-hand side loads all dependencies at the start. Sparse on-demand retrieval thus dominates push-based communication in context cost. More importantly, progressive fetching establishes communication channels dynamically rather than fixing them at decomposition time, allowing the collaboration graph to adapt to dependencies not fully determined in advance. This converts global topology prediction into localized retrieval decisions grounded in execution feedback.

4.2 渐进式边解析

子任务节点之间的边通过渐进式消息拉取（progressive message fetching）建立。每个智能体在完成时写入自己的结果，只在需要时才获取依赖。令 \mathcal{B}_{k} 表示进入子任务 \tau_{(k)} 的桥边集合，\operatorname{idx}(x_{q},\tau_{(k)}) 表示对 x_{p} 的依赖开始生效的步骤。渐进式拉取产生的成本为

\sum_{(x_{p},x_{q})\in\mathcal{B}_{k}}\sum_{i=\operatorname{idx}(x_{q},\tau_{(k)})}^{T_{k}}c(x_{p})\leq\sum_{(x_{p},x_{q})\in\mathcal{B}_{k}}\sum_{i=1}^{T_{k}}c(x_{p}),   (7)

其中右侧对应在开始时就加载全部依赖的做法。因此，就上下文成本而言，稀疏的按需检索优于基于推送的通信。更重要的是，渐进式拉取以动态方式建立通信通道，而不是在分解时就将其固定下来，从而使协作图能够适应那些无法事先完全确定的依赖。这便把全局拓扑预测转化为以执行反馈为依据的局部检索决策。

[¶28]

5 Experiments

5 实验

[¶29]

5.1 Experimental Setup

5.1 实验设置

[¶30]

5.1.1 Benchmarks

We evaluate on four benchmarks designed to assess agent capabilities on complex, long-horizon, realistic tasks. Terminal Bench 2.1 (Merrill et al., 2026) tests agents on hard, realistic command-line interface tasks, with resolution rate as the primary metric. NL2Repo Bench (Ding et al., 2026) evaluates long-horizon repository generation from a single natural-language requirements document, using the average test pass rate across all tasks as the primary metric. Deep Research Bench II (Li et al., 2026) diagnoses deep research agents through rubrics derived from expert reports, scored as the fraction of rubrics passed. AgentIF-OneDay (Chen et al., 2026) is a task-level instruction-following benchmark for general AI agents in daily scenarios, employing instance-level, rubric-based scoring with binary evaluation, separated bonus/penalty items, and file-content alignment. Detailed descriptions of all benchmarks are provided in Appendix B.1.

5.1.1 基准

我们在四个基准上进行评测，它们旨在考察智能体在复杂、长程且贴近真实的任务上的能力。Terminal Bench 2.1 (Merrill et al., 2026) 在困难且贴近真实的命令行界面任务上测试智能体，主要指标为解决率。NL2Repo Bench (Ding et al., 2026) 评测依据单份自然语言需求文档完成的长程代码仓库生成，主要指标为所有任务的平均测试通过率。Deep Research Bench II (Li et al., 2026) 借助从专家报告中提炼出的评分细则（rubric）来诊断深度研究智能体，得分为通过的评分细则所占的比例。AgentIF-OneDay (Chen et al., 2026) 是一个面向日常场景中通用 AI 智能体的任务级指令遵循基准，采用实例级、基于评分细则的打分方式，具备二元评判、加分项与扣分项分离以及文件内容对齐等特点。所有基准的详细介绍见附录 B.1。

[¶31]

5.1.2 Baselines

Single-Agent executes the full task within a single agent context and serves as the monolithic baseline. It runs on the native Codex CLI harness (OpenAI, 2025b). Task Decomposition and Agent Generation (TDAG) (Wang et al., 2025b) is a multi-agent framework that decomposes complex tasks into smaller subtasks, assigns each subtask to a specifically generated subagent, and continuously summarizes successful execution patterns into reusable skills for future reference. DynTaskMAS (Yu et al., 2025) is a dynamic task graph-driven framework for asynchronous and parallel LLM-based multi-agent systems. Graph-of-Agents (GoA) (Yun et al., 2026) models multi-agent LLM communication through a graph-based framework, sampling relevant agents, constructing edges by evaluating response relevance, and aggregating responses via graph-based pooling. Further details on baseline implementations are provided in Appendix B.2.

5.1.2 基线

Single-Agent 在单个智能体的上下文中执行完整任务，作为整体式基线。它运行在原生的 Codex CLI harness (OpenAI, 2025b) 之上。Task Decomposition and Agent Generation (TDAG) (Wang et al., 2025b) 是一个多智能体框架，它将复杂任务分解为更小的子任务，把每个子任务分配给一个专门生成的子智能体，并持续把成功的执行模式总结为可复用的技能，供日后参考。DynTaskMAS (Yu et al., 2025) 是一个由动态任务图驱动的框架，面向基于 LLM 的异步、并行多智能体系统。Graph-of-Agents (GoA) (Yun et al., 2026) 通过一个基于图的框架来建模多智能体 LLM 之间的通信：采样相关智能体，通过评估回复之间的相关性来构建边，并借助基于图的池化来聚合回复。基线实现的更多细节见附录 B.2。

[¶32]

5.1.3 Implementation

To ensure harness consistency, all methods are instantiated on the Codex CLI harness. For multi-agent methods, token usage is aggregated across all agents. All baselines and our approach are built upon DeepSeek-V4-Pro (DeepSeek, 2026c) as the foundation LLM. For all multi-agent methods evaluated in this work, we impose a uniform constraint on agent hierarchy: the maximum recursion depth is set to 1, meaning that spawned sub-agents are not permitted to recursively create further sub-agents. Additionally, the maximum number of agents is capped at 4. These constraints are imposed uniformly across all multi-agent methods to ensure system stability and prevent unbounded agent proliferation during execution. We examine the effect of relaxing these constraints in the ablation study (Section 5.4) and further verify it on the multi-agent baselines in Appendix B.3.

5.1.3 实现细节

为保证 harness 一致，所有方法均在 Codex CLI harness 上实例化。对于多智能体方法，token 用量按所有智能体汇总计算。所有基线与本文方法均以 DeepSeek-V4-Pro (DeepSeek, 2026c) 作为基座 LLM。对于本文评测的所有多智能体方法，我们对智能体层级施加统一约束：最大递归深度（maximum recursion depth）设为 1，即派生出的子智能体不允许再递归地创建下一级子智能体。此外，最大智能体数量上限设为 4。这些约束统一施加于所有多智能体方法，以确保系统稳定，并防止执行过程中智能体无节制地增殖。我们在消融实验（第 5.4 节）中考察放宽这些约束的影响，并在附录 B.3 中针对各多智能体基线做了进一步验证。

[¶33]

5.2 Main Results

Table 1 presents the main results across all four benchmarks, reporting the primary metric along with input and output token counts for each benchmark.

Table 1: Main results across four long-horizon agent benchmarks. For each benchmark, we report the primary metric and token usage. The best result for each metric is underlined.

5.2 主要结果

表 1 给出了全部四个基准上的主要结果，报告了每个基准的主要指标以及输入与输出 token 数。

表 1：四个长程智能体基准上的主要结果。对每个基准，我们报告其主要指标与 token 用量。各项指标的最佳结果以下划线标示（本译文以粗体标示）。

[¶34]

	Terminal Bench 2.1	NL2Repo	Deep Research Bench II	AgentIF-OneDay
Method	Resolution Rate ↑	Pass Rate ↑	Total Score ↑	Total Score ↑
Single-Agent	76.71	48.74	51.49	53.57
TDAG	71.49	47.37	54.43	59.94
DynTaskMAS	68.27	44.15	53.44	65.85
GoA	67.47	41.04	48.40	52.67
SAIGE (Ours)	75.50	49.23	55.23	71.80
Token Usage (Input / Output) ↓
Single-Agent	475M / 8M	1,408M / 10M	2,805M / 7M	189M / 2M
TDAG	542M / 13M	1,562M / 15M	3,895M / 23M	218M / 3M
DynTaskMAS	533M / 12M	1,386M / 15M	3,240M / 21M	233M / 4M
GoA	621M / 16M	1,380M / 14M	3,816M / 23M	222M / 3M
SAIGE (Ours)	501M / 10M	1,282M / 11M	2,745M / 20M	185M / 3M

[¶35]

[Figure 3: Failure taxonomy across four benchmarks.]

The four benchmarks differ in the dependency structure of their execution trajectories. Terminal Bench 2.1 and NL2Repo Bench exhibit dense inter-step dependencies: tool invocations, file reads, and file writes form long upstream-downstream chains in which later steps must condition on earlier outputs, leaving little room for independent execution. Deep Research Bench II and AgentIF-OneDay, by contrast, exhibit sparse dependencies, where large portions of the trajectory can proceed without conditioning on one another. This distinction provides a principled basis for the two regimes of multi-agent behavior observed below, with step-level evidence in Appendix C.

[图 3：四个基准上的失败分类（failure taxonomy）。]

四个基准在执行轨迹的依赖结构上各不相同。Terminal Bench 2.1 与 NL2Repo Bench 呈现出稠密的步间依赖：工具调用、文件读取与文件写入构成很长的上下游链条，后续步骤必须以前序步骤的输出为条件，几乎没有独立执行的余地。相比之下，Deep Research Bench II 与 AgentIF-OneDay 呈现出稀疏依赖，轨迹中的大部分内容无需以彼此为条件即可推进。这一区别为下文所观察到的多智能体行为的两种情形提供了有理可循的解释依据，步骤级证据见附录 C。

[¶36]

On the densely coupled benchmarks, generic multi-agent methods fall below the single-agent baseline, suggesting that decomposition fragments the dependency chain and that coordination overhead can outweigh the benefit of context isolation. SAIGE does not exhibit the same degradation: it remains comparable to the single-agent baseline on Terminal Bench 2.1 and on NL2Repo Bench, while using fewer tokens than the other multi-agent methods. On the sparsely dependent benchmarks, decomposition appears more beneficial, and SAIGE performs competitively on both, with the most visible margin on AgentIF-OneDay, without the token inflation observed in the other multi-agent variants. GoA, by contrast, employs a more elaborate orchestration design yet yields weaker results on these benchmarks, which suggests that added coordination complexity does not by itself translate into gains when it is not matched to the task’s dependency structure.

在稠密耦合的基准上，通用多智能体方法的表现低于单智能体基线，这表明分解割裂了依赖链，且协调开销可能超过上下文隔离带来的收益。SAIGE 并未出现同样的性能退化：它在 Terminal Bench 2.1 和 NL2Repo Bench 上与单智能体基线表现相当，同时消耗的 token 少于其他多智能体方法。在稀疏依赖的基准上，分解显得更有益处，SAIGE 在这两个基准上均表现出竞争力，其中在 AgentIF-OneDay 上的领先幅度最为明显，并且没有出现其他多智能体变体中观察到的 token 膨胀。相比之下，GoA 采用了更为精细的编排设计，在这些基准上的结果却更弱，这表明，若新增的协调复杂度与任务的依赖结构不相匹配，其本身并不能转化为收益。

[¶37]

Taken together, these results are consistent with our central claim that the benefit of multi-agent collaboration is bounded by task structure rather than universal. SAIGE does not dominate the single-agent baseline on every benchmark, and its advantage is most evident on sparsely dependent tasks. Across both regimes, however, it appears to attain a favorable trade-off: it avoids the decomposition penalty on tightly coupled tasks, exploits context isolation on decomposable ones, and grows its collaboration graph in response to execution feedback rather than a pre-committed topology.

综合来看，这些结果与我们的核心论断相一致：多智能体协作的收益受任务结构约束，而非普遍成立。SAIGE 并非在每个基准上都优于单智能体基线，其优势在稀疏依赖的任务上最为明显。不过，在两种情形下，它似乎都取得了较为有利的权衡：在紧耦合任务上避免了分解代价，在可分解任务上利用了上下文隔离，并依据执行反馈、而非预先确定的拓扑来扩展其协作图。

[¶38]

5.3 Failure Pattern Analysis

To understand how multi-agent collaboration affects execution, we collect trajectories whose evaluation scores are significantly below the benchmark average and use DeepSeek-V4-Pro to semantically analyze their execution traces, yielding three recurring failure categories: Task Understanding and Execution Failure (TUEF), Incomplete Workflow and Premature Termination (IWPT), and Local Deadlock (LD). Figure 3 summarizes their distribution across the four benchmarks.

On the tightly coupled benchmarks, multi-agent methods are more prone to Local Deadlock: coordination introduces waiting, cyclic dependencies, and resource conflicts that prevent global progress. On the decomposable benchmarks, by contrast, single-agent methods more frequently exhibit Incomplete Workflow and Premature Termination, as the accumulation of context progressively degrades their ability to track the full tool chain, leading them to stop before the workflow is validated or the resolution criterion is satisfied. These two tendencies together clarify why multi-agent collaboration is beneficial only when the task structure admits effective decomposition.

5.3 失败模式分析

为了理解多智能体协作如何影响执行，我们收集了评测得分显著低于基准平均水平的轨迹，并使用 DeepSeek-V4-Pro 对其执行记录进行语义分析，归纳出三类反复出现的失败类别：任务理解与执行失败（Task Understanding and Execution Failure，TUEF）、工作流不完整与过早终止（Incomplete Workflow and Premature Termination，IWPT），以及局部死锁（Local Deadlock，LD）。图 3 汇总了它们在四个基准上的分布情况。

在紧耦合的基准上，多智能体方法更容易陷入局部死锁：协调引入了等待、循环依赖和资源冲突，阻碍了全局进展。相比之下，在可分解的基准上，单智能体方法更频繁地出现工作流不完整与过早终止，因为上下文的累积会逐步削弱它们追踪完整工具链的能力，导致其在工作流通过验证或满足解决判定标准之前就停止执行。这两种倾向共同说明了为何只有在任务结构允许有效分解时，多智能体协作才会带来益处。

[¶39]

5.4 Ablation Study

We conduct ablation experiments on Deep Research Bench II and AgentIF-OneDay to examine the sensitivity of SAIGE to agent count, recursion depth, and progressive message fetching. Tables 2 and 3 report the primary benchmark score and aggregated token usage across all agents for each configuration. For each recursion depth setting, we vary the maximum number of agents to isolate their joint effects, with “w/o Message Fetching” denoting SAIGE with progressive message fetching disabled under the default recursion depth (D_{\max}=1).

Table 2: Ablation results on Deep Research Bench II. The default configuration is underlined.

5.4 消融实验

我们在 Deep Research Bench II 和 AgentIF-OneDay 上开展消融实验，考察 SAIGE 对智能体数量、递归深度和渐进式消息拉取的敏感性。表 2 和表 3 报告了各配置下的基准主指标得分，以及所有智能体累计的 token 用量。对于每一种递归深度设置，我们都改变智能体数量上限，以厘清二者的联合效应；其中「去掉消息拉取」表示在默认递归深度（D_{\max}=1）下禁用渐进式消息拉取的 SAIGE。

表 2：Deep Research Bench II 上的消融结果。默认配置以下划线标出（本译文以粗体标示）。

[¶40]

	Max Recursion Depth
Configuration	D_{\max}=1	D_{\max}=2	D_{\max}=3	w/o Message Fetching
Total Score ↑
N_{\max}=4	55.23	54.88	52.21	53.54
N_{\max}=5	52.94	52.07	50.89	53.85
N_{\max}=6	53.74	48.94	49.07	51.22
Token Usage (Input / Output) ↓
N_{\max}=4	2,745M / 20M	3,102M / 19M	2,993M / 21M	4,027M / 24M
N_{\max}=5	3,913M / 25M	4,225M / 24M	4,502M / 25M	5,928M / 26M
N_{\max}=6	6,312M / 32M	6,782M / 34M	6,590M / 31M	6,951M / 34M

[¶41]

Table 3: Ablation results on AgentIF-OneDay. The default configuration is underlined.

表 3：AgentIF-OneDay 上的消融结果。默认配置以下划线标出（本译文以粗体标示）。

[¶42]

	Max Recursion Depth
Configuration	D_{\max}=1	D_{\max}=2	D_{\max}=3	w/o Message Fetching
Total Score ↑
N_{\max}=4	71.80	66.39	63.17	66.22
N_{\max}=5	67.32	58.33	58.76	59.15
N_{\max}=6	64.02	60.16	56.75	53.50
Token Usage (Input / Output) ↓
N_{\max}=4	185M / 3M	261M / 4M	272M / 4M	237M / 3M
N_{\max}=5	239M / 3M	272M / 4M	270M / 3M	268M / 3M
N_{\max}=6	352M / 4M	360M / 4M	371M / 4M	366M / 4M

[¶43]

Across the tested configurations, increasing the agent budget does not consistently improve task performance. On both benchmarks, expanding the agent pool beyond the default setting tends to yield lower scores and higher token consumption, with individual configurations deviating from this trend. Deepening the recursion level shows a similar pattern: allowing sub-agents to spawn further sub-agents tends to reduce performance and increase token usage. Disabling progressive message fetching is also associated with a comparable decline, most notably on AgentIF-OneDay. Token usage generally increases with agent count and recursion depth, while task performance does not show a corresponding gain. These results suggest that more agents do not necessarily make a system more intelligent: beyond a certain point, the marginal agent appears to add coordination cost with limited additional problem-solving capacity.

在所测试的各项配置中，增加智能体预算并不能稳定地提升任务表现。在两个基准上，将智能体池扩展到默认设置以上，往往会带来更低的得分和更高的 token 消耗，仅有个别配置偏离这一趋势。加深递归层级也呈现出类似的规律：允许子智能体继续派生子智能体，往往会降低性能并增加 token 用量。禁用渐进式消息拉取同样伴随着相当程度的下降，在 AgentIF-OneDay 上尤为明显。token 用量总体上随智能体数量和递归深度的增加而上升，而任务表现并未出现相应的提升。这些结果表明，更多的智能体并不一定让系统更智能：超过某个临界点之后，边际上每多出的一个智能体似乎只会增加协调成本，而带来的额外问题求解能力十分有限。

[¶44]

6 Conclusion

In this work, we reexamine the value of multi-agent collaboration in the era of increasingly capable single-agent harnesses. Through a graph-theoretic formalization of task trajectories, we show that multi-agent collaboration is not universally beneficial, but confers systematic advantages specifically on long-horizon tasks with sparse dependencies, where context isolation can be exploited without incurring prohibitive coordination overhead. Building on this insight, we propose SAIGE, a multi-agent collaboration mechanism that models collaboration as a dynamically evolving graph and establishes semantic dependencies through content-based information retrieval. Experiments on long-horizon benchmarks show that SAIGE achieves a favorable trade-off between context efficiency and task performance. These findings suggest that multi-agent superiority is bounded by task structure rather than universal, and that indiscriminate scaling of agents warrants reconsideration.

6 结论

在本文中，我们在单智能体 harness 能力日益强大的时代，重新审视了多智能体协作的价值。通过对任务轨迹进行图论形式化，我们表明多智能体协作并非普遍有益，而是特别在具有稀疏依赖的长程任务上带来系统性优势——在这类任务中，上下文隔离可以得到利用，而不会招致过高的协调开销。基于这一洞见，我们提出了 SAIGE：一种将协作建模为动态演化的图、并通过基于内容的信息检索建立语义依赖的多智能体协作机制。在长程基准上的实验表明，SAIGE 在上下文效率与任务表现之间取得了有利的权衡。这些发现表明，多智能体的优越性受任务结构约束，而非普遍成立；不加区分地扩增智能体规模的做法值得重新审视。

[¶45]

Appendix A Proofs

Theorem 1. Let \tau=\{x_{1},x_{2},\ldots,x_{T}\} be a task trajectory with no redundant interactions, and let \mathcal{E} denote the set of directed edges defined by the dependency criterion. Then the graph \mathcal{G}=(\mathcal{V},\mathcal{E}) with \mathcal{V}=\tau is a weakly connected directed acyclic graph.

Proof. For any edge (x_{i},x_{t})\in\mathcal{E}, the dependency criterion requires i<t, since the value function Q_{t} is evaluated with respect to the historical context \mathcal{H}_{t}=\{x_{1},\ldots,x_{t-1}\}. Thus every edge is oriented from a lower-index vertex to a higher-index vertex.

Define a mapping \phi:\mathcal{V}\to\mathbb{N} by \phi(x_{i})=i. For every edge (x_{i},x_{t})\in\mathcal{E}, we have

附录 A 证明

定理 1. 设 \tau=\{x_{1},x_{2},\ldots,x_{T}\} 为一条不含冗余交互的任务轨迹，并令 \mathcal{E} 表示由依赖判据所定义的有向边集合。则图 \mathcal{G}=(\mathcal{V},\mathcal{E})（其中 \mathcal{V}=\tau）是一个弱连通的有向无环图。

证明. 对于任意边 (x_{i},x_{t})\in\mathcal{E}，依赖判据要求 i<t，因为价值函数 Q_{t} 是相对于历史上下文 \mathcal{H}_{t}=\{x_{1},\ldots,x_{t-1}\} 进行评估的。因此，每条边都由索引较小的顶点指向索引较大的顶点。

定义映射 \phi:\mathcal{V}\to\mathbb{N} 为 \phi(x_{i})=i。对于每条边 (x_{i},x_{t})\in\mathcal{E}，我们有

[¶46]

\phi(x_{i})=i<t=\phi(x_{t}).

Therefore \phi is a strict order-preserving labeling of the vertices, which is a well-known sufficient condition for acyclicity. Equivalently, any directed path

x_{i_{1}}\to x_{i_{2}}\to\cdots\to x_{i_{\ell}}

must satisfy

i_{1}<i_{2}<\cdots<i_{\ell},

precluding the existence of a directed cycle. Hence \mathcal{G} is a directed acyclic graph.

We next establish weak connectivity. By assumption, every node in \tau contributes to at least one subsequent decision, implying that every vertex x_{i} with i<T has out-degree at least one, and the terminal vertex x_{T} is the unique sink. Hence, for every vertex x_{i} with i<T, there exists a directed path from x_{i} to x_{T}: starting from x_{i}, each step follows an outgoing edge (x_{i},x_{j}) with j>i, and since indices strictly increase along edges and the trajectory is finite, the path must terminate at x_{T}.

\phi(x_{i})=i<t=\phi(x_{t}).

因此，\phi 是对顶点的一个严格保序标号，而这是图无环的一个众所周知的充分条件。等价地，任意有向路径

x_{i_{1}}\to x_{i_{2}}\to\cdots\to x_{i_{\ell}}

都必须满足

i_{1}<i_{2}<\cdots<i_{\ell},

从而排除了有向环的存在。因此 \mathcal{G} 是一个有向无环图。

接下来我们证明弱连通性。由假设，\tau 中的每个节点都至少对一个后续决策有贡献，这意味着每个满足 i<T 的顶点 x_{i} 的出度至少为一，且终止顶点 x_{T} 是唯一的汇点。因此，对于每个满足 i<T 的顶点 x_{i}，都存在一条从 x_{i} 到 x_{T} 的有向路径：从 x_{i} 出发，每一步都沿一条满足 j>i 的出边 (x_{i},x_{j}) 前进；由于索引沿边严格递增且轨迹是有限的，该路径必然终止于 x_{T}。

[¶47]

Now consider any two vertices x_{i},x_{j}\in\mathcal{V}. If i=j the claim is trivial. Otherwise, there exists a directed path P_{i} from x_{i} to x_{T} and a directed path P_{j} from x_{j} to x_{T}. Reversing the orientation of P_{j} yields an undirected path from x_{T} to x_{j}. Concatenating P_{i} with the reversed P_{j} gives an undirected walk from x_{i} to x_{j} in the underlying undirected graph of \mathcal{G}. Therefore any two vertices are connected in the underlying undirected graph, and \mathcal{G} is weakly connected. ∎

Theorem 2. Let \mathcal{G}=(\mathcal{V},\mathcal{E}) be a weakly connected directed acyclic graph, and let \mathcal{E}^{*}\subseteq\mathcal{E} be the set of bridge edges. Define \mathcal{V}_{\mathcal{S}} as the set of weakly connected components of \mathcal{G}\setminus\mathcal{E}^{*}, and let

现在考虑任意两个顶点 x_{i},x_{j}\in\mathcal{V}。若 i=j，结论显然成立。否则，存在一条从 x_{i} 到 x_{T} 的有向路径 P_{i}，以及一条从 x_{j} 到 x_{T} 的有向路径 P_{j}。将 P_{j} 反向，即得到一条从 x_{T} 到 x_{j} 的无向路径。将 P_{i} 与反向后的 P_{j} 相接，便在 \mathcal{G} 的底层无向图（underlying undirected graph）中得到一条从 x_{i} 到 x_{j} 的无向途径（walk）。因此，任意两个顶点在底层无向图中都是连通的，即 \mathcal{G} 是弱连通的。∎

定理 2. 设 \mathcal{G}=(\mathcal{V},\mathcal{E}) 为一个弱连通的有向无环图，并令 \mathcal{E}^{*}\subseteq\mathcal{E} 为桥边集合。定义 \mathcal{V}_{\mathcal{S}} 为 \mathcal{G}\setminus\mathcal{E}^{*} 的弱连通分量所构成的集合，并令

[¶48]

\mathcal{E}_{\mathcal{S}}=\{(\mathcal{C}_{p},\mathcal{C}_{q})\mid\exists(u,v)\in\mathcal{E}^{*}\text{ with }u\in\mathcal{C}_{p},v\in\mathcal{C}_{q}\}.

Then \mathcal{T}=(\mathcal{V}_{\mathcal{S}},\mathcal{E}_{\mathcal{S}}) is a tree.

Proof. We first prove that \mathcal{T} is connected. Since \mathcal{G} is weakly connected, its underlying undirected graph is connected. Contracting each weakly connected component \mathcal{C}_{i}\in\mathcal{V}_{\mathcal{S}} to a single vertex preserves weak connectivity of the quotient graph. The edge set of this quotient graph is precisely \mathcal{E}_{\mathcal{S}}, as all edges between distinct components are bridge edges. Hence \mathcal{T} is weakly connected.

\mathcal{E}_{\mathcal{S}}=\{(\mathcal{C}_{p},\mathcal{C}_{q})\mid\exists(u,v)\in\mathcal{E}^{*}\text{ with }u\in\mathcal{C}_{p},v\in\mathcal{C}_{q}\}.

则 \mathcal{T}=(\mathcal{V}_{\mathcal{S}},\mathcal{E}_{\mathcal{S}}) 是一棵树。

证明. 我们首先证明 \mathcal{T} 是连通的。由于 \mathcal{G} 是弱连通的，其底层无向图是连通的。将每个弱连通分量 \mathcal{C}_{i}\in\mathcal{V}_{\mathcal{S}} 收缩为单个顶点，所得商图（quotient graph）的弱连通性保持不变。该商图的边集恰为 \mathcal{E}_{\mathcal{S}}，因为不同分量之间的所有边都是桥边。因此 \mathcal{T} 是弱连通的。

[¶49]

We next prove that \mathcal{T} is acyclic. Suppose, for contradiction, that \mathcal{T} contains an undirected cycle C_{\mathcal{S}} of length \ell\geq 2, with vertices

\mathcal{C}_{i_{1}},\mathcal{C}_{i_{2}},\ldots,\mathcal{C}_{i_{\ell}}

and edges

e_{1},e_{2},\ldots,e_{\ell}\in\mathcal{E}_{\mathcal{S}},

where e_{j}=(\mathcal{C}_{i_{j}},\mathcal{C}_{i_{j+1}}) with indices taken modulo \ell.

By the definition of \mathcal{E}_{\mathcal{S}}, each e_{j} corresponds to a bridge edge (u_{j},v_{j})\in\mathcal{E}^{*} with

u_{j}\in\mathcal{C}_{i_{j}}\quad\text{and}\quad v_{j}\in\mathcal{C}_{i_{j+1}}.

Since each \mathcal{C}_{i_{j}} is weakly connected, there exists an undirected path P_{j} within \mathcal{C}_{i_{j+1}} connecting v_{j} to u_{j+1}, with indices modulo \ell.

接下来我们证明 \mathcal{T} 是无环的。用反证法，假设 \mathcal{T} 包含一个长度为 \ell\geq 2 的无向环 C_{\mathcal{S}}，其顶点为

\mathcal{C}_{i_{1}},\mathcal{C}_{i_{2}},\ldots,\mathcal{C}_{i_{\ell}}

边为

e_{1},e_{2},\ldots,e_{\ell}\in\mathcal{E}_{\mathcal{S}},

其中 e_{j}=(\mathcal{C}_{i_{j}},\mathcal{C}_{i_{j+1}})，下标按模 \ell 取值。

由 \mathcal{E}_{\mathcal{S}} 的定义，每条 e_{j} 都对应一条桥边 (u_{j},v_{j})\in\mathcal{E}^{*}，满足

u_{j}\in\mathcal{C}_{i_{j}}\quad\text{and}\quad v_{j}\in\mathcal{C}_{i_{j+1}}.

由于每个 \mathcal{C}_{i_{j}} 都是弱连通的，在 \mathcal{C}_{i_{j+1}} 内部存在一条连接 v_{j} 与 u_{j+1} 的无向路径 P_{j}，下标同样按模 \ell 取值。

[¶50]

Concatenating the bridge edge (u_{j},v_{j}) with the path P_{j} for each j yields an undirected cycle in \mathcal{G} that contains the bridge edge (u_{1},v_{1}) but does not traverse it twice. The removal of (u_{1},v_{1}) therefore does not disconnect u_{1} from v_{1}, as the alternative route through

P_{1},e_{2},P_{2},\ldots,e_{\ell}

remains. This contradicts the defining property of a bridge edge, namely that its removal destroys all paths between its endpoints. Therefore \mathcal{T} contains no undirected cycle.

A weakly connected graph with no undirected cycles is a tree, completing the proof. ∎

Lemma 1. For any trajectory \tau_{(S)}=\tau_{(L)}\cup\tau_{(R)} partitioned into two subtask trajectories by a single bridge edge (x_{L},x_{R}) with x_{L}\in\tau_{(L)} and x_{R}\in\tau_{(R)}, the sum of the context costs of the two subtask trajectories is no greater than the cost of the original trajectory:

对每个 j，将桥边 (u_{j},v_{j}) 与路径 P_{j} 依次相接，便得到 \mathcal{G} 中的一个无向环，它包含桥边 (u_{1},v_{1})，且不会两次经过该边。因此，删除 (u_{1},v_{1}) 并不会使 u_{1} 与 v_{1} 断开，因为经由

P_{1},e_{2},P_{2},\ldots,e_{\ell}

的替代路线依然存在。这与桥边的定义性质相矛盾——删除桥边会破坏其两个端点之间的所有路径。因此 \mathcal{T} 不包含无向环。

不含无向环的弱连通图是一棵树，证毕。∎

引理 1. 对于任意轨迹 \tau_{(S)}=\tau_{(L)}\cup\tau_{(R)}，若它被单条桥边 (x_{L},x_{R}) 划分为两条子任务轨迹，其中 x_{L}\in\tau_{(L)} 且 x_{R}\in\tau_{(R)}，则两条子任务轨迹的上下文成本之和不大于原轨迹的成本：

[¶51]

C(\tau_{(L)})+C(\tau_{(R)})\leq C(\tau_{(S)}).

Proof. We proceed by analyzing the internal and external context costs separately, then combine the two bounds to establish the result.

C(\tau_{(L)})+C(\tau_{(R)})\leq C(\tau_{(S)}).

证明. 我们分别分析内部上下文成本与外部上下文成本，再将两个界合并，从而得到结论。

[¶52]

Setup and notation.

Both subsequences preserve the original temporal order, so every node in \tau_{(L)} precedes every node in \tau_{(R)}. For any trajectory \tau and node x_{i}\in\tau, let \operatorname{idx}(x_{i},\tau) denote the position of x_{i} in \tau.

For any trajectory \tau, the internal context cost can be rewritten as

C_{I}(\tau)=\sum_{x_{i}\in\tau}c(x_{i})\cdot\bigl|\{x_{t}\in\tau:\operatorname{idx}(x_{i},\tau)<\operatorname{idx}(x_{t},\tau)\}\bigr|,

which charges each node x_{i} for every subsequent node in the same trajectory that must retain x_{i} in its historical context.

For any trajectory \tau with incoming bridge edge set \mathcal{B}(\tau)\subseteq\mathcal{E}^{*}, the external context cost can be rewritten as

设定与记号。

两个子序列均保持原有的时间顺序，因此 \tau_{(L)} 中的每个节点都位于 \tau_{(R)} 中每个节点之前。对任意轨迹 \tau 及节点 x_{i}\in\tau，令 \operatorname{idx}(x_{i},\tau) 表示 x_{i} 在 \tau 中的位置。

对任意轨迹 \tau，其内部上下文成本可改写为

C_{I}(\tau)=\sum_{x_{i}\in\tau}c(x_{i})\cdot\bigl|\{x_{t}\in\tau:\operatorname{idx}(x_{i},\tau)<\operatorname{idx}(x_{t},\tau)\}\bigr|,

该式的含义是：同一轨迹中每有一个后续节点须在其历史上下文中保留 x_{i}，就为节点 x_{i} 计一次成本。

对任意入向桥边集合为 \mathcal{B}(\tau)\subseteq\mathcal{E}^{*} 的轨迹 \tau，其外部上下文成本可改写为

[¶53]

C_{E}(\tau)=\sum_{(x_{p},x_{q})\in\mathcal{B}(\tau)}c(x_{p})\cdot\bigl|\{x_{t}\in\tau:\operatorname{idx}(x_{q},\tau)\leq\operatorname{idx}(x_{t},\tau)\}\bigr|,

which charges each predecessor node x_{p} for every node in \tau that must retain x_{p} after it is pulled across the bridge edge (x_{p},x_{q}).

The total context cost is C(\tau)=C_{I}(\tau)+C_{E}(\tau).

C_{E}(\tau)=\sum_{(x_{p},x_{q})\in\mathcal{B}(\tau)}c(x_{p})\cdot\bigl|\{x_{t}\in\tau:\operatorname{idx}(x_{q},\tau)\leq\operatorname{idx}(x_{t},\tau)\}\bigr|,

该式的含义是：每个前驱节点 x_{p} 经桥边 (x_{p},x_{q}) 被拉取进来之后，\tau 中每有一个节点须保留 x_{p}，就为该前驱节点计一次成本。

总上下文成本为 C(\tau)=C_{I}(\tau)+C_{E}(\tau)。

[¶54]

Internal cost difference.

Since \tau_{(S)}=\tau_{(L)}\cup\tau_{(R)}, the internal cost of \tau_{(S)} decomposes as

\displaystyle C_{I}(\tau_{(S)})
\displaystyle=C_{I}(\tau_{(L)})+C_{I}(\tau_{(R)})
\displaystyle+\sum_{x_{i}\in\tau_{(L)}}c(x_{i})\cdot\bigl|\{x_{t}\in\tau_{(R)}:\operatorname{idx}(x_{i},\tau_{(S)})<\operatorname{idx}(x_{t},\tau_{(S)})\}\bigr|
\displaystyle+\sum_{x_{j}\in\tau_{(R)}}c(x_{j})\cdot\bigl|\{x_{t}\in\tau_{(L)}:\operatorname{idx}(x_{j},\tau_{(S)})<\operatorname{idx}(x_{t},\tau_{(S)})\}\bigr|.

The first extra term accounts for the fact that in the monolithic trajectory, nodes in \tau_{(R)} must retain preceding nodes in \tau_{(L)} in their context. The second extra term is symmetric: it accounts for nodes in \tau_{(R)} whose context must be retained by subsequent nodes in \tau_{(L)}. Since both extra terms are non-negative, dropping the second term yields the lower bound

内部成本之差。

由于 \tau_{(S)}=\tau_{(L)}\cup\tau_{(R)}，\tau_{(S)} 的内部成本可分解为

\displaystyle C_{I}(\tau_{(S)})
\displaystyle=C_{I}(\tau_{(L)})+C_{I}(\tau_{(R)})
\displaystyle+\sum_{x_{i}\in\tau_{(L)}}c(x_{i})\cdot\bigl|\{x_{t}\in\tau_{(R)}:\operatorname{idx}(x_{i},\tau_{(S)})<\operatorname{idx}(x_{t},\tau_{(S)})\}\bigr|
\displaystyle+\sum_{x_{j}\in\tau_{(R)}}c(x_{j})\cdot\bigl|\{x_{t}\in\tau_{(L)}:\operatorname{idx}(x_{j},\tau_{(S)})<\operatorname{idx}(x_{t},\tau_{(S)})\}\bigr|.

第一个附加项对应的事实是：在整体轨迹中，\tau_{(R)} 中的节点必须在其上下文中保留 \tau_{(L)} 中位于它们之前的节点。第二个附加项与之对称：它对应 \tau_{(R)} 中那些须由 \tau_{(L)} 中后续节点保留在上下文中的节点。由于两个附加项均非负，舍去第二项即得下界

[¶55]

C_{I}(\tau_{(S)})-C_{I}(\tau_{(L)})-C_{I}(\tau_{(R)})\geq\sum_{x_{i}\in\tau_{(L)}}c(x_{i})\cdot\bigl|\{x_{t}\in\tau_{(R)}:\operatorname{idx}(x_{i},\tau_{(S)})<\operatorname{idx}(x_{t},\tau_{(S)})\}\bigr|.   (8)

C_{I}(\tau_{(S)})-C_{I}(\tau_{(L)})-C_{I}(\tau_{(R)})\geq\sum_{x_{i}\in\tau_{(L)}}c(x_{i})\cdot\bigl|\{x_{t}\in\tau_{(R)}:\operatorname{idx}(x_{i},\tau_{(S)})<\operatorname{idx}(x_{t},\tau_{(S)})\}\bigr|.   (8)

[¶56]

External cost difference.

Let \mathcal{B}_{S} be the set of bridge edges entering \tau_{(S)}. After partitioning by the bridge edge (x_{L},x_{R}), the incoming bridge edge sets for the two subtasks are

\mathcal{B}_{L}=\{(x_{p},x_{q})\in\mathcal{B}_{S}\mid x_{q}\in\tau_{(L)}\},\qquad\mathcal{B}_{R}=\{(x_{p},x_{q})\in\mathcal{B}_{S}\mid x_{q}\in\tau_{(R)}\}\cup\{(x_{L},x_{R})\}.

We claim that \mathcal{B}_{S} decomposes disjointly as

\mathcal{B}_{S}=\mathcal{B}_{L}\cup\bigl(\mathcal{B}_{R}\setminus\{(x_{L},x_{R})\}\bigr),

with \mathcal{B}_{L}\cap\bigl(\mathcal{B}_{R}\setminus\{(x_{L},x_{R})\}\bigr)=\varnothing. Indeed, suppose for contradiction that there exists a bridge edge (x_{p},x_{q})\in\mathcal{B}_{L}\cap\bigl(\mathcal{B}_{R}\setminus\{(x_{L},x_{R})\}\bigr). Then x_{q} would belong to both \tau_{(L)} and \tau_{(R)}, contradicting the fact that \tau_{(L)} and \tau_{(R)} are disjoint subtask trajectories obtained by removing the bridge edge (x_{L},x_{R}).

外部成本之差。

令 \mathcal{B}_{S} 为进入 \tau_{(S)} 的桥边集合。沿桥边 (x_{L},x_{R}) 划分之后，两个子任务各自的入向桥边集合为

\mathcal{B}_{L}=\{(x_{p},x_{q})\in\mathcal{B}_{S}\mid x_{q}\in\tau_{(L)}\},\qquad\mathcal{B}_{R}=\{(x_{p},x_{q})\in\mathcal{B}_{S}\mid x_{q}\in\tau_{(R)}\}\cup\{(x_{L},x_{R})\}.

我们断言 \mathcal{B}_{S} 可不相交地分解为

\mathcal{B}_{S}=\mathcal{B}_{L}\cup\bigl(\mathcal{B}_{R}\setminus\{(x_{L},x_{R})\}\bigr),

且 \mathcal{B}_{L}\cap\bigl(\mathcal{B}_{R}\setminus\{(x_{L},x_{R})\}\bigr)=\varnothing。事实上，用反证法，假设存在桥边 (x_{p},x_{q})\in\mathcal{B}_{L}\cap\bigl(\mathcal{B}_{R}\setminus\{(x_{L},x_{R})\}\bigr)。那么 x_{q} 将同时属于 \tau_{(L)} 与 \tau_{(R)}，这与 \tau_{(L)} 和 \tau_{(R)} 是移除桥边 (x_{L},x_{R}) 后得到的两条互不相交的子任务轨迹这一事实相矛盾。

[¶57]

The external cost of the original trajectory is

\displaystyle C_{E}(\tau_{(S)})
\displaystyle=\sum_{(x_{p},x_{q})\in\mathcal{B}_{L}}c(x_{p})\cdot\bigl|\{x_{t}\in\tau_{(S)}:\operatorname{idx}(x_{q},\tau_{(S)})\leq\operatorname{idx}(x_{t},\tau_{(S)})\}\bigr|
\displaystyle+\sum_{(x_{p},x_{q})\in\mathcal{B}_{R}\setminus\{(x_{L},x_{R})\}}c(x_{p})\cdot\bigl|\{x_{t}\in\tau_{(S)}:\operatorname{idx}(x_{q},\tau_{(S)})\leq\operatorname{idx}(x_{t},\tau_{(S)})\}\bigr|.

The external costs of the two subtasks are

\displaystyle C_{E}(\tau_{(L)})+C_{E}(\tau_{(R)})
\displaystyle=\sum_{(x_{p},x_{q})\in\mathcal{B}_{L}}c(x_{p})\cdot\bigl|\{x_{t}\in\tau_{(L)}:\operatorname{idx}(x_{q},\tau_{(L)})\leq\operatorname{idx}(x_{t},\tau_{(L)})\}\bigr|
\displaystyle+\sum_{(x_{p},x_{q})\in\mathcal{B}_{R}\setminus\{(x_{L},x_{R})\}}c(x_{p})\cdot\bigl|\{x_{t}\in\tau_{(R)}:\operatorname{idx}(x_{q},\tau_{(R)})\leq\operatorname{idx}(x_{t},\tau_{(R)})\}\bigr|
\displaystyle+c(x_{L})\cdot\bigl|\{x_{t}\in\tau_{(R)}:\operatorname{idx}(x_{R},\tau_{(R)})\leq\operatorname{idx}(x_{t},\tau_{(R)})\}\bigr|.

原轨迹的外部成本为

\displaystyle C_{E}(\tau_{(S)})
\displaystyle=\sum_{(x_{p},x_{q})\in\mathcal{B}_{L}}c(x_{p})\cdot\bigl|\{x_{t}\in\tau_{(S)}:\operatorname{idx}(x_{q},\tau_{(S)})\leq\operatorname{idx}(x_{t},\tau_{(S)})\}\bigr|
\displaystyle+\sum_{(x_{p},x_{q})\in\mathcal{B}_{R}\setminus\{(x_{L},x_{R})\}}c(x_{p})\cdot\bigl|\{x_{t}\in\tau_{(S)}:\operatorname{idx}(x_{q},\tau_{(S)})\leq\operatorname{idx}(x_{t},\tau_{(S)})\}\bigr|.

两个子任务的外部成本为

\displaystyle C_{E}(\tau_{(L)})+C_{E}(\tau_{(R)})
\displaystyle=\sum_{(x_{p},x_{q})\in\mathcal{B}_{L}}c(x_{p})\cdot\bigl|\{x_{t}\in\tau_{(L)}:\operatorname{idx}(x_{q},\tau_{(L)})\leq\operatorname{idx}(x_{t},\tau_{(L)})\}\bigr|
\displaystyle+\sum_{(x_{p},x_{q})\in\mathcal{B}_{R}\setminus\{(x_{L},x_{R})\}}c(x_{p})\cdot\bigl|\{x_{t}\in\tau_{(R)}:\operatorname{idx}(x_{q},\tau_{(R)})\leq\operatorname{idx}(x_{t},\tau_{(R)})\}\bigr|
\displaystyle+c(x_{L})\cdot\bigl|\{x_{t}\in\tau_{(R)}:\operatorname{idx}(x_{R},\tau_{(R)})\leq\operatorname{idx}(x_{t},\tau_{(R)})\}\bigr|.

[¶58]

For any (x_{p},x_{q})\in\mathcal{B}_{L}, since \tau_{(L)}\subseteq\tau_{(S)} and the relative positions of nodes within \tau_{(L)} are preserved in \tau_{(S)}, we have \operatorname{idx}(x_{q},\tau_{(L)})=\operatorname{idx}(x_{q},\tau_{(S)}). Consequently,

\{x_{t}\in\tau_{(L)}:\operatorname{idx}(x_{q},\tau_{(L)})\leq\operatorname{idx}(x_{t},\tau_{(L)})\}\subseteq\{x_{t}\in\tau_{(S)}:\operatorname{idx}(x_{q},\tau_{(S)})\leq\operatorname{idx}(x_{t},\tau_{(S)})\},

and therefore

\displaystyle\bigl|\{x_{t}\in\tau_{(L)}:\operatorname{idx}(x_{q},\tau_{(L)})\leq\operatorname{idx}(x_{t},\tau_{(L)})\}\bigr|
\displaystyle\leq\bigl|\{x_{t}\in\tau_{(S)}:\operatorname{idx}(x_{q},\tau_{(S)})\leq\operatorname{idx}(x_{t},\tau_{(S)})\}\bigr|.

对任意 (x_{p},x_{q})\in\mathcal{B}_{L}，由于 \tau_{(L)}\subseteq\tau_{(S)}，且 \tau_{(L)} 内各节点的相对位置在 \tau_{(S)} 中保持不变，故有 \operatorname{idx}(x_{q},\tau_{(L)})=\operatorname{idx}(x_{q},\tau_{(S)})。因此，

\{x_{t}\in\tau_{(L)}:\operatorname{idx}(x_{q},\tau_{(L)})\leq\operatorname{idx}(x_{t},\tau_{(L)})\}\subseteq\{x_{t}\in\tau_{(S)}:\operatorname{idx}(x_{q},\tau_{(S)})\leq\operatorname{idx}(x_{t},\tau_{(S)})\},

从而

\displaystyle\bigl|\{x_{t}\in\tau_{(L)}:\operatorname{idx}(x_{q},\tau_{(L)})\leq\operatorname{idx}(x_{t},\tau_{(L)})\}\bigr|
\displaystyle\leq\bigl|\{x_{t}\in\tau_{(S)}:\operatorname{idx}(x_{q},\tau_{(S)})\leq\operatorname{idx}(x_{t},\tau_{(S)})\}\bigr|.

[¶59]

The same argument applies to any (x_{p},x_{q})\in\mathcal{B}_{R}\setminus\{(x_{L},x_{R})\}, yielding

\displaystyle\bigl|\{x_{t}\in\tau_{(R)}:\operatorname{idx}(x_{q},\tau_{(R)})\leq\operatorname{idx}(x_{t},\tau_{(R)})\}\bigr|
\displaystyle\leq\bigl|\{x_{t}\in\tau_{(S)}:\operatorname{idx}(x_{q},\tau_{(S)})\leq\operatorname{idx}(x_{t},\tau_{(S)})\}\bigr|.

Thus, comparing the expressions for C_{E}(\tau_{(S)}) and C_{E}(\tau_{(L)})+C_{E}(\tau_{(R)}) term by term, the only term present in the subtask costs but absent from the original cost is the newly introduced bridge edge cost

c(x_{L})\cdot\bigl|\{x_{t}\in\tau_{(R)}:\operatorname{idx}(x_{R},\tau_{(R)})\leq\operatorname{idx}(x_{t},\tau_{(R)})\}\bigr|.

同样的论证适用于任意 (x_{p},x_{q})\in\mathcal{B}_{R}\setminus\{(x_{L},x_{R})\}，由此得到

\displaystyle\bigl|\{x_{t}\in\tau_{(R)}:\operatorname{idx}(x_{q},\tau_{(R)})\leq\operatorname{idx}(x_{t},\tau_{(R)})\}\bigr|
\displaystyle\leq\bigl|\{x_{t}\in\tau_{(S)}:\operatorname{idx}(x_{q},\tau_{(S)})\leq\operatorname{idx}(x_{t},\tau_{(S)})\}\bigr|.

于是，逐项比较 C_{E}(\tau_{(S)}) 与 C_{E}(\tau_{(L)})+C_{E}(\tau_{(R)}) 的表达式可知，出现在子任务成本中而不出现在原成本中的唯一一项，是新引入的桥边成本

c(x_{L})\cdot\bigl|\{x_{t}\in\tau_{(R)}:\operatorname{idx}(x_{R},\tau_{(R)})\leq\operatorname{idx}(x_{t},\tau_{(R)})\}\bigr|.

[¶60]

Therefore,

C_{E}(\tau_{(S)})-C_{E}(\tau_{(L)})-C_{E}(\tau_{(R)})\geq-c(x_{L})\cdot\bigl|\{x_{t}\in\tau_{(R)}:\operatorname{idx}(x_{R},\tau_{(R)})\leq\operatorname{idx}(x_{t},\tau_{(R)})\}\bigr|.   (9)

因此，

C_{E}(\tau_{(S)})-C_{E}(\tau_{(L)})-C_{E}(\tau_{(R)})\geq-c(x_{L})\cdot\bigl|\{x_{t}\in\tau_{(R)}:\operatorname{idx}(x_{R},\tau_{(R)})\leq\operatorname{idx}(x_{t},\tau_{(R)})\}\bigr|.   (9)

[¶61]

Combining the bounds.

Combining (8) and (9), we have

\displaystyle C(\tau_{(S)})-C(\tau_{(L)})-C(\tau_{(R)})
\displaystyle=\bigl[C_{I}(\tau_{(S)})-C_{I}(\tau_{(L)})-C_{I}(\tau_{(R)})\bigr]
\displaystyle+\bigl[C_{E}(\tau_{(S)})-C_{E}(\tau_{(L)})-C_{E}(\tau_{(R)})\bigr]
\displaystyle\geq\sum_{x_{i}\in\tau_{(L)}}c(x_{i})\cdot\bigl|\{x_{t}\in\tau_{(R)}:\operatorname{idx}(x_{i},\tau_{(S)})<\operatorname{idx}(x_{t},\tau_{(S)})\}\bigr|
\displaystyle-c(x_{L})\cdot\bigl|\{x_{t}\in\tau_{(R)}:\operatorname{idx}(x_{R},\tau_{(R)})\leq\operatorname{idx}(x_{t},\tau_{(R)})\}\bigr|.

Since x_{L}\in\tau_{(L)}, the first sum contains the term corresponding to x_{i}=x_{L}:

合并两个界。

结合式 (8) 与式 (9)，有

\displaystyle C(\tau_{(S)})-C(\tau_{(L)})-C(\tau_{(R)})
\displaystyle=\bigl[C_{I}(\tau_{(S)})-C_{I}(\tau_{(L)})-C_{I}(\tau_{(R)})\bigr]
\displaystyle+\bigl[C_{E}(\tau_{(S)})-C_{E}(\tau_{(L)})-C_{E}(\tau_{(R)})\bigr]
\displaystyle\geq\sum_{x_{i}\in\tau_{(L)}}c(x_{i})\cdot\bigl|\{x_{t}\in\tau_{(R)}:\operatorname{idx}(x_{i},\tau_{(S)})<\operatorname{idx}(x_{t},\tau_{(S)})\}\bigr|
\displaystyle-c(x_{L})\cdot\bigl|\{x_{t}\in\tau_{(R)}:\operatorname{idx}(x_{R},\tau_{(R)})\leq\operatorname{idx}(x_{t},\tau_{(R)})\}\bigr|.

由于 x_{L}\in\tau_{(L)}，第一个求和式中包含 x_{i}=x_{L} 所对应的项：

[¶62]

\displaystyle\sum_{x_{i}\in\tau_{(L)}}c(x_{i})\cdot\bigl|\{x_{t}\in\tau_{(R)}:\operatorname{idx}(x_{i},\tau_{(S)})<\operatorname{idx}(x_{t},\tau_{(S)})\}\bigr|
\displaystyle\geq c(x_{L})\cdot\bigl|\{x_{t}\in\tau_{(R)}:\operatorname{idx}(x_{L},\tau_{(S)})<\operatorname{idx}(x_{t},\tau_{(S)})\}\bigr|.

Because (x_{L},x_{R}) is a bridge edge, we have \operatorname{idx}(x_{L},\tau_{(S)})<\operatorname{idx}(x_{R},\tau_{(S)}), and hence

\{x_{t}\in\tau_{(R)}:\operatorname{idx}(x_{R},\tau_{(S)})\leq\operatorname{idx}(x_{t},\tau_{(S)})\}\subseteq\{x_{t}\in\tau_{(R)}:\operatorname{idx}(x_{L},\tau_{(S)})<\operatorname{idx}(x_{t},\tau_{(S)})\}.

\displaystyle\sum_{x_{i}\in\tau_{(L)}}c(x_{i})\cdot\bigl|\{x_{t}\in\tau_{(R)}:\operatorname{idx}(x_{i},\tau_{(S)})<\operatorname{idx}(x_{t},\tau_{(S)})\}\bigr|
\displaystyle\geq c(x_{L})\cdot\bigl|\{x_{t}\in\tau_{(R)}:\operatorname{idx}(x_{L},\tau_{(S)})<\operatorname{idx}(x_{t},\tau_{(S)})\}\bigr|.

由于 (x_{L},x_{R}) 是桥边，有 \operatorname{idx}(x_{L},\tau_{(S)})<\operatorname{idx}(x_{R},\tau_{(S)})，因而

\{x_{t}\in\tau_{(R)}:\operatorname{idx}(x_{R},\tau_{(S)})\leq\operatorname{idx}(x_{t},\tau_{(S)})\}\subseteq\{x_{t}\in\tau_{(R)}:\operatorname{idx}(x_{L},\tau_{(S)})<\operatorname{idx}(x_{t},\tau_{(S)})\}.

[¶63]

Since \operatorname{idx}(x_{R},\tau_{(R)})=\operatorname{idx}(x_{R},\tau_{(S)}), this implies

\displaystyle\bigl|\{x_{t}\in\tau_{(R)}:\operatorname{idx}(x_{R},\tau_{(R)})\leq\operatorname{idx}(x_{t},\tau_{(R)})\}\bigr|
\displaystyle\leq\bigl|\{x_{t}\in\tau_{(R)}:\operatorname{idx}(x_{L},\tau_{(S)})<\operatorname{idx}(x_{t},\tau_{(S)})\}\bigr|.

Therefore, the first term in the lower bound dominates the second term, and we obtain

\displaystyle C(\tau_{(S)})-C(\tau_{(L)})-C(\tau_{(R)})
\displaystyle\geq c(x_{L})\cdot\bigl|\{x_{t}\in\tau_{(R)}:\operatorname{idx}(x_{L},\tau_{(S)})<\operatorname{idx}(x_{t},\tau_{(S)})\}\bigr|
\displaystyle-c(x_{L})\cdot\bigl|\{x_{t}\in\tau_{(R)}:\operatorname{idx}(x_{R},\tau_{(R)})\leq\operatorname{idx}(x_{t},\tau_{(R)})\}\bigr|
\displaystyle\geq 0.

由于 \operatorname{idx}(x_{R},\tau_{(R)})=\operatorname{idx}(x_{R},\tau_{(S)})，这意味着

\displaystyle\bigl|\{x_{t}\in\tau_{(R)}:\operatorname{idx}(x_{R},\tau_{(R)})\leq\operatorname{idx}(x_{t},\tau_{(R)})\}\bigr|
\displaystyle\leq\bigl|\{x_{t}\in\tau_{(R)}:\operatorname{idx}(x_{L},\tau_{(S)})<\operatorname{idx}(x_{t},\tau_{(S)})\}\bigr|.

因此，下界中的第一项不小于第二项，从而得到

\displaystyle C(\tau_{(S)})-C(\tau_{(L)})-C(\tau_{(R)})
\displaystyle\geq c(x_{L})\cdot\bigl|\{x_{t}\in\tau_{(R)}:\operatorname{idx}(x_{L},\tau_{(S)})<\operatorname{idx}(x_{t},\tau_{(S)})\}\bigr|
\displaystyle-c(x_{L})\cdot\bigl|\{x_{t}\in\tau_{(R)}:\operatorname{idx}(x_{R},\tau_{(R)})\leq\operatorname{idx}(x_{t},\tau_{(R)})\}\bigr|
\displaystyle\geq 0.

[¶64]

Thus,

C(\tau_{(L)})+C(\tau_{(R)})\leq C(\tau_{(S)}),

which completes the proof. ∎

于是，

C(\tau_{(L)})+C(\tau_{(R)})\leq C(\tau_{(S)}),

至此证明完毕。∎

[¶65]

Appendix B Experimental Details

附录 B 实验细节

[¶66]

B.1 Benchmark Details

Terminal Bench 2.1 [Merrill et al., 2026] is a curated hard benchmark composed of tasks in computer terminal environments inspired by real-world workflows. Each task features a unique environment, a human-written solution, and comprehensive tests for verification. Because the framework is interactive, agent and model performance are difficult to decouple; many agent scaffolds are engineered to accommodate the tendencies of specific models, and agents are not explicitly required to use a terminal as their sole tool. To remain faithful to the benchmark’s premise, a neutral testbed with a single headless terminal is adopted, and tasks are completed using only Bash commands. The primary metric is the resolution rate. In our evaluation, each task is attempted three times, and the resolution rate is computed as the number of tasks completed in a run divided by the total number of tasks, averaged over the three runs.

B.1 基准测试细节

Terminal Bench 2.1 [Merrill et al., 2026] 是一个经过精心筛选的高难度基准，由一系列受真实工作流启发、在计算机终端环境中完成的任务构成。每个任务都配有专属的环境、一份人工编写的解法，以及用于验证的完整测试。由于该框架是交互式的，智能体与模型各自的表现难以解耦：许多智能体脚手架（agent scaffold）都针对特定模型的行为倾向做了专门设计，而且该基准并未明确要求智能体只能以终端作为唯一工具。为忠实于该基准的设定前提，我们采用只含单个无头（headless）终端的中立测试平台，任务全部仅用 Bash 命令完成。主要指标为解决率。在我们的评测中，每个任务尝试三次；解决率按单次运行中完成的任务数除以任务总数计算，再对三次运行取平均。

[¶67]

NL2Repo Bench [Ding et al., 2026] evaluates repository-level coding abilities with verifiable ground truth. Tasks are derived from real-world Python libraries characterized by modular architectures and authoritative pytest suites. Agents receive only a single natural-language specification and must reconstruct the complete repository from scratch, including file structures and functional logic. Correctness is strictly measured by executing the generated code against the original upstream tests. Each task is scored by the fraction of unit tests it passes, and the final benchmark score is the average of these per-task pass rates across all tasks.

NL2Repo Bench [Ding et al., 2026] 以可验证的标准答案（ground truth）评估仓库级编码能力。其任务取自真实世界中的 Python 库，这些库具有模块化的架构和权威的 pytest 测试套件。智能体仅获得一份自然语言规格说明，必须从零开始重建完整的代码仓库，包括文件结构与功能逻辑。正确性的衡量十分严格：以原始的上游测试来执行所生成的代码。每个任务的得分为其通过的单元测试所占比例，基准最终得分为所有任务上这些单任务通过率的平均值。

[¶68]

Deep Research Bench II [Li et al., 2026] diagnoses deep research agents through rubrics derived from expert reports. The benchmark evaluates agents on information recall, analysis, and presentation, with rubrics constructed through a four-stage pipeline of LLM extraction, self-evaluation iteration, manual revision, and expert review. For each task, the score is the fraction of rubrics it passes, and the final benchmark score is computed as the total number of rubrics passed divided by the total number of rubrics across all tasks.

AgentIF-OneDay [Chen et al., 2026] is a task-level instruction-following benchmark for general AI agents in daily scenarios. It employs instance-level, rubric-based scoring with three key properties: binary scoring, where each rubric item is strictly evaluated as satisfied or not to ensure objectivity; distinction between bonus and penalty items, separating capability assessment from error rates; and file-content alignment, enabling direct evaluation of agent-generated files alongside textual output. Let N be the total number of problems. For the i-th problem, let S_{i}^{+} and S_{i}^{-} denote the sum of satisfied bonus points and triggered penalty points, and S_{i}^{\max} the maximum achievable score. The normalized score is

Deep Research Bench II [Li et al., 2026] 借助源自专家报告的评分细则（rubric）来诊断深度研究智能体。该基准从信息召回、分析与呈现三个方面评估智能体，其评分细则经由四阶段流程构建：LLM 抽取、自评迭代、人工修订与专家审核。每个任务的得分为其通过的评分细则所占比例；基准最终得分按所有任务中通过的评分细则总数除以评分细则总数计算。

AgentIF-OneDay [Chen et al., 2026] 是一个面向日常场景下通用 AI 智能体的任务级指令遵循基准。它采用实例级、基于评分细则的评分方式，并具备三个关键特性：一是二元评分，每条评分细则都被严格判定为满足或不满足，以确保客观性；二是区分加分项与扣分项，将能力评估与错误率区分开来；三是文件内容对齐，使智能体生成的文件能与文本输出一同被直接评估。设 N 为题目总数。对第 i 道题，令 S_{i}^{+} 与 S_{i}^{-} 分别表示已满足的加分项分值之和与被触发的扣分项分值之和，S_{i}^{\max} 表示可获得的最高分。归一化得分为

[¶69]

s_{i}=\frac{\max(0,S_{i}^{+}-S_{i}^{-})}{S_{i}^{\max}},   (10)

and the final benchmark score is the mean of these normalized scores:

\mathrm{Score}_{\mathrm{final}}=\frac{1}{N}\sum_{i=1}^{N}s_{i}.   (11)

Because AgentIF-OneDay involves multimodal requirements such as image editing and in-depth research, while DeepSeek-V4-Pro [DeepSeek, 2026c] does not natively support multimodal input, we provide a multimodal skill that allows the agent to invoke DeepSeek-V4-Flash-Vision-Exp [DeepSeek, 2026b] for image understanding. This skill is implemented as a script that the agent can invoke directly, so the agent can decide when to delegate visual perception to the vision model without altering the benchmark’s evaluation protocol.

s_{i}=\frac{\max(0,S_{i}^{+}-S_{i}^{-})}{S_{i}^{\max}},   (10)

基准最终得分为这些归一化得分的均值：

\mathrm{Score}_{\mathrm{final}}=\frac{1}{N}\sum_{i=1}^{N}s_{i}.   (11)

由于 AgentIF-OneDay 涉及图像编辑、深度调研等多模态需求，而 DeepSeek-V4-Pro [DeepSeek, 2026c] 并不原生支持多模态输入，我们提供了一个多模态 skill，使智能体可以调用 DeepSeek-V4-Flash-Vision-Exp [DeepSeek, 2026b] 进行图像理解。该 skill 以脚本形式实现，智能体可直接调用，因而能够自行决定何时把视觉感知委托给视觉模型，同时不改变基准的评测协议。

[¶70]

B.2 Baseline Details

Single-Agent executes the full task within a single agent context, serving as the monolithic baseline. It runs on the native Codex CLI harness [OpenAI, 2025b].

Task Decomposition and Agent Generation (TDAG) [Wang et al., 2025b] is a multi-agent framework built on dynamic task decomposition and agent generation. It decomposes complex tasks into smaller subtasks and assigns each subtask to a specifically generated subagent, thereby improving adaptability in diverse and unpredictable real-world tasks. The decomposition is not static: subtasks are dynamically adjusted based on the outcomes of preceding tasks, allowing the framework to refine the task structure as execution unfolds. Successful execution patterns are further summarized into reusable skills for future reference.

B.2 基线方法细节

Single-Agent 在单个智能体的上下文中执行完整任务，作为不做任务拆分的整体式基线。它运行在原生的 Codex CLI harness [OpenAI, 2025b] 之上。

Task Decomposition and Agent Generation (TDAG) [Wang et al., 2025b] 是一个基于动态任务分解与智能体生成的多智能体框架。它将复杂任务分解为更小的子任务，并把每个子任务分配给专门生成的子智能体，从而提升在多样且难以预测的真实世界任务中的适应性。这种分解并非静态的：子任务会依据先前任务的结果动态调整，使框架能够随执行的推进不断细化任务结构。此外，成功的执行模式还会被总结为可复用的 skill，供后续参考。

[¶71]

DynTaskMAS [Yu et al., 2025] is a dynamic task graph-driven framework for asynchronous and parallel LLM-based multi-agent systems. It orchestrates asynchronous and parallel operations through dynamic task graphs, and comprises four key components: a Dynamic Task Graph Generator that decomposes complex tasks while maintaining logical dependencies, an Asynchronous Parallel Execution Engine that optimizes resource utilization through efficient task scheduling, a Semantic-Aware Context Management System that enables efficient information sharing among agents, and an Adaptive Workflow Manager that dynamically optimizes system performance. This design supports scalable, high-performance multi-agent execution on complex, dynamic tasks.

DynTaskMAS [Yu et al., 2025] 是一个由动态任务图驱动的框架，面向基于 LLM 的异步并行多智能体系统。它借助动态任务图来编排异步与并行操作，由四个关键组件构成：动态任务图生成器（Dynamic Task Graph Generator），在保持逻辑依赖的前提下分解复杂任务；异步并行执行引擎（Asynchronous Parallel Execution Engine），通过高效的任务调度优化资源利用；语义感知上下文管理系统（Semantic-Aware Context Management System），实现智能体之间高效的信息共享；以及自适应工作流管理器（Adaptive Workflow Manager），动态优化系统性能。这一设计支持在复杂、动态的任务上进行可扩展的高性能多智能体执行。

[¶72]

Graph-of-Agents (GoA) [Yun et al., 2026] models multi-agent LLM communication through a graph-based framework. It first samples relevant agents from a candidate pool, then constructs edges between them by evaluating the relevance of their responses to one another, and finally aggregates the refined responses via graph-based pooling. Message passing proceeds in two stages, source-to-target followed by target-to-source, allowing highly relevant agents to refine the responses of less relevant ones and vice versa. To ensure consistency of the base model across all evaluated methods, we do not adopt GoA’s original multi-source LLM design, in which different agents are backed by different foundation models. Instead, we instantiate all agents with the same foundation LLM and differentiate them by assigning distinct roles, so that the comparison isolates the effect of orchestration rather than that of heterogeneous model capabilities.

Graph-of-Agents (GoA) [Yun et al., 2026] 通过一个基于图的框架来建模多智能体 LLM 之间的通信。它首先从候选池中采样相关的智能体，然后通过评估各智能体回答之间的相互相关性在它们之间构建边，最后借助基于图的池化（graph-based pooling）聚合经过精炼的回答。消息传递分两个阶段进行：先从源到目标，再从目标到源，使高相关度的智能体能够精炼低相关度智能体的回答，反之亦然。为保证所有被评估方法的基座模型一致，我们没有采用 GoA 原有的多源 LLM 设计（在该设计中，不同智能体由不同的基座模型支撑），而是用同一个基座 LLM 实例化所有智能体，并通过分配不同角色来加以区分，从而使对比所隔离出的是编排本身的作用，而非异构模型能力的影响。

[¶73]

B.3 Detailed Experimental Results

B.3 详细实验结果

[¶74]

B.3.1 Detailed Main Results

Beyond the aggregate metrics in Table 1, we report the detailed breakdown when a benchmark provides finer-grained evaluation dimensions.

Table 4: Detailed results on Deep Research Bench II.

B.3.1 主实验详细结果

除表 1 中的汇总指标外，对于提供了更细粒度评估维度的基准，我们还报告其详细分项结果。

表 4：Deep Research Bench II 上的详细结果。

[¶75]

Method	Info Recall	Analysis	Presentation	Total Score
Single-Agent	47.57	52.08	92.49	51.94
TDAG	50.72	53.56	91.15	54.43
DynTaskMAS	48.85	54.69	93.57	53.44
GoA	43.11	50.77	92.49	48.40
SAIGE (Ours)	51.40	54.33	93.16	55.23

[¶76]

Table 5: Detailed results on AgentIF-OneDay.

表 5：AgentIF-OneDay 上的详细结果。

[¶77]

Method	Content	Form	Execution	Total Score
Single-Agent	51.76	47.57	43.71	53.57
TDAG	60.92	59.42	48.12	59.94
DynTaskMAS	66.18	59.35	48.39	65.85
GoA	53.04	48.99	41.08	52.67
SAIGE (Ours)	68.77	60.95	54.81	71.80

[¶78]

B.3.2 Further Ablation Study

We further examine the ablation results under the five configurations for the multi-agent baselines. As shown in Figure 4, increasing the agent count or deepening the recursion level generally reduces the task score while increasing token consumption. Across both benchmarks and both baselines, i.e., TDAG and DynTaskMAS, the default configuration (N=4,D=1) attains the most favorable overall trade-off between task performance and token cost, whereas the remaining configurations fall into the lower-right region relative to the default. This indicates that additional agents or deeper recursion introduce coordination overhead without improving problem-solving capacity.

B.3.2 进一步消融研究

我们进一步考察多智能体基线在五种配置下的消融结果。如图 4 所示，增加智能体数量或加深递归层级通常会降低任务得分，同时增加 token 消耗。在两个基准与两种基线（即 TDAG 和 DynTaskMAS）上，默认配置 (N=4,D=1) 都在任务性能与 token 成本之间取得了整体上最有利的权衡，而其余配置相对于默认配置均落在右下方区域。这表明，增加智能体或加深递归会引入协调开销，却不能提升解决问题的能力。

[¶79]

[Figure 4: Ablation results under five configurations. Each point corresponds to one configuration.]

[图 4：五种配置下的消融结果。每个点对应一种配置。]

[¶80]

B.3.3 Fine-Grained Analysis

To examine whether SAIGE performs conditional subtask decomposition according to task dependency structure rather than spawning agents indiscriminately, we record the average number of agents instantiated per task on each benchmark. We further evaluate whether the predicted bridge edges correspond to the ground-truth dependency boundaries.

[Figure 5: Average agent number per task across four benchmarks.]

[Figure 6: Bridge-edge decomposition accuracy on AgentIF-OneDay.]

As shown in Figure 6, SAIGE instantiates substantially fewer agents on Terminal Bench 2.1 and NL2Repo Bench, where the trajectory exhibits dense inter-step dependencies and most subtasks cannot be executed independently. On Deep Research Bench II and AgentIF-OneDay, whose trajectories are sparsely dependent, SAIGE spawns more agents and exploits context isolation more aggressively. The agent count therefore tracks the dependency structure of the benchmark rather than a fixed allocation policy, which is consistent with the conditional delegation criterion. Notably, the average agent number remains below the maximum budget on all four benchmarks, indicating that SAIGE does not expand its collaboration graph beyond what the task structure permits.

B.3.3 细粒度分析

为检验 SAIGE 是否依据任务依赖结构进行条件式子任务分解，而非不加区分地派生智能体，我们记录了每个基准上平均每个任务实例化的智能体数量。我们还进一步评估了预测出的桥边是否与真实（ground-truth）依赖边界相对应。

[图 5：四个基准上平均每个任务的智能体数量。]

[图 6：AgentIF-OneDay 上的桥边分解准确率。]

如图 5 所示，在 Terminal Bench 2.1 和 NL2Repo Bench 上，SAIGE 实例化的智能体明显更少：这两个基准的轨迹呈现出密集的步间依赖，大多数子任务无法独立执行。而在轨迹为稀疏依赖的 Deep Research Bench II 和 AgentIF-OneDay 上，SAIGE 会派生更多智能体，更积极地利用上下文隔离。因此，智能体数量跟随的是基准的依赖结构，而非某种固定的分配策略，这与条件委派准则相一致。值得注意的是，在全部四个基准上，平均智能体数量都低于预算上限，说明 SAIGE 不会把协作图扩张到任务结构所允许的范围之外。

[¶81]

To obtain a ground-truth decomposition for AgentIF-OneDay, we first collect the successful trajectories produced by the Single-Agent baseline on this benchmark. For each such trajectory, we construct a semantic dependency matrix with DeepSeek-V4-Pro: for every step t and each earlier step i<t, the model judges whether step t semantically conditions on the output of step i, i.e., whether the action or observation at step t would change if x_{i} were removed from the history. This yields a binary dependency matrix. Bridge edges are then identified as the single-step dependencies whose removal partitions the trajectory into weakly connected components, and the resulting components define the ground-truth decomposition points at which the task can be split into independently executable subtasks.

为得到 AgentIF-OneDay 的真实分解，我们首先收集 Single-Agent 基线在该基准上产生的成功轨迹。对每条这样的轨迹，我们用 DeepSeek-V4-Pro 构建语义依赖矩阵：对于每个步骤 t 及其之前的每个步骤 i<t，由模型判断步骤 t 是否在语义上以步骤 i 的输出为条件，即如果从历史中移除 x_{i}，步骤 t 的动作或观测是否会随之改变。由此得到一个二值依赖矩阵。随后，我们把那些一旦移除就会将轨迹划分为若干弱连通分量的单步依赖识别为桥边；由此得到的各个分量界定了真实的分解点，任务可在这些点上拆分为可独立执行的子任务。

[¶82]

We then evaluate the decomposition produced by each multi-agent method against this ground truth. For every sub-agent trajectory generated by a method, we semantically match its instruction and executed steps to the ground-truth subtask components using DeepSeek-V4-Pro, and count a predicted bridge edge as correct if it connects the same pair of subtask components as a ground-truth bridge edge. Precision, recall, and F1 are computed over the matched bridge edges across all tasks.

Figure 6 reports the results on AgentIF-OneDay. SAIGE achieves the most accurate decomposition among all multi-agent methods, indicating that its incremental, execution-grounded edge prediction recovers the true dependency boundaries more faithfully than static or pre-committed decomposition strategies. The improvement is most pronounced in recall, suggesting that SAIGE is less prone to omitting bridge edges, which is precisely the failure mode that produces local deadlocks. These results provide direct evidence that the performance gains of SAIGE on sparsely dependent benchmarks are accompanied by, and plausibly attributable to, more accurate bridge-edge prediction.

接着，我们以这一真实分解为参照，评估各多智能体方法给出的分解。对于某一方法生成的每条子智能体轨迹，我们用 DeepSeek-V4-Pro 将其指令和已执行的步骤在语义上匹配到真实的子任务分量；若一条预测桥边与某条真实桥边连接的是同一对子任务分量，则计为正确。精确率、召回率和 F1 均基于全部任务中已匹配的桥边计算。

图 6 报告了 AgentIF-OneDay 上的结果。SAIGE 在所有多智能体方法中取得了最准确的分解，表明其增量式、以执行为依据的边预测比静态或预先固定的分解策略更忠实地还原了真实的依赖边界。提升在召回率上最为明显，说明 SAIGE 更不容易遗漏桥边——而这恰恰是导致局部死锁的失败模式。这些结果提供了直接证据：SAIGE 在稀疏依赖基准上的性能提升伴随着更准确的桥边预测，并且很可能正是源于这一点。

[¶83]

Appendix C Case Study

附录 C 案例研究

[¶84]

C.1 Task Dependency Patterns

To illustrate the task dependency patterns that underlie our analysis, we select one representative single-agent trajectory from Terminal Bench 2.1 and one from AgentIF-OneDay, and construct their dependency matrices through semantic dependency analysis. Specifically, for each step t in the trajectory, we take the history \mathcal{H}_{t}=\{x_{1},\ldots,x_{t-1}\} and perform semantic analysis with DeepSeek-V4-Pro to assess, for each earlier step i<t, whether step t semantically conditions on the output of step i, i.e., whether the action or observation at step t would change if x_{i} were removed from the history. This yields a binary dependency matrix A\in\{0,1\}^{T\times T} with A_{t,i}=1 if step t depends on step i, and A_{t,i}=0 otherwise.

C.1 任务依赖模式

为说明支撑我们分析的任务依赖模式，我们从 Terminal Bench 2.1 和 AgentIF-OneDay 中各选取一条具有代表性的单智能体轨迹，并通过语义依赖分析构建它们的依赖矩阵。具体而言，对轨迹中的每个步骤 t，我们取其历史 \mathcal{H}_{t}=\{x_{1},\ldots,x_{t-1}\}，用 DeepSeek-V4-Pro 进行语义分析，针对每个更早的步骤 i<t 判断步骤 t 是否在语义上以步骤 i 的输出为条件，即如果从历史中移除 x_{i}，步骤 t 的动作或观测是否会随之改变。由此得到一个二值依赖矩阵 A\in\{0,1\}^{T\times T}：若步骤 t 依赖于步骤 i，则 A_{t,i}=1，否则 A_{t,i}=0。

[¶85]

[Figure 7: Dependency matrices of representative single-agent trajectories.]

Figure 7 shows the resulting dependency matrices for the two trajectories. The Terminal Bench 2.1 trajectory exhibits a dense dependency pattern in which a non-negligible fraction of steps depend on distant predecessors, producing long-range dependencies that span a wide range of earlier steps. This is consistent with the long upstream-downstream chains induced by continuous tool invocations, file reads, and file writes, where later steps must consume the outputs of earlier ones and independent execution is rarely possible. The AgentIF-OneDay trajectory, by contrast, exhibits a sparse and localized pattern: non-zero entries concentrate near the diagonal, indicating that most steps depend only on their immediate predecessors and that large portions of the trajectory can proceed without conditioning on one another. This contrast directly reflects the two structural regimes identified in our analysis, and provides a step-level view of why multi-agent decomposition is constrained on tightly coupled benchmarks while remaining feasible on sparsely dependent ones.

[图 7：代表性单智能体轨迹的依赖矩阵。]

图 7 展示了这两条轨迹对应的依赖矩阵。Terminal Bench 2.1 的轨迹呈现出密集的依赖模式：有不可忽视的一部分步骤依赖于相距较远的前驱步骤，形成横跨大量先前步骤的长距离依赖。这与连续的工具调用、文件读取和文件写入所引发的长上下游链条相吻合：在这类链条中，后续步骤必须消费先前步骤的输出，几乎不可能独立执行。相比之下，AgentIF-OneDay 的轨迹呈现出稀疏且局部化的模式：非零元素集中在对角线附近，表明大多数步骤只依赖于紧邻的前驱步骤，轨迹的大部分片段无需彼此依赖即可推进。这一对比直接反映了我们分析中识别出的两种结构情形，并从步骤层面说明了为何多智能体分解在紧耦合基准上受到制约，而在稀疏依赖基准上依然可行。

[¶86]

C.2 Bridge Edge Mis-Prediction: A Local Deadlock Case

We illustrate the effect of bridge edge mis-prediction on a representative task from Terminal Bench 2.1, make-doom-for-mips, in which the agent must build a MIPS ELF that runs under a supplied JavaScript MIPS VM. The task contains a long upstream-downstream chain: the VM defines the syscall ABI and the memory layout, the build must target a compatible MIPS ABI, and the resulting ELF must be validated by running it inside the VM. A correct decomposition must preserve the bridge edges that connect these stages.

[Figure 8: Ground-truth and mis-predicted dependency structures on make-doom-for-mips.]

C.2 桥边误预测：一个局部死锁案例

我们以 Terminal Bench 2.1 中的代表性任务 make-doom-for-mips 为例，说明桥边误预测的影响。在该任务中，智能体必须构建一个 MIPS ELF，使其能在给定的、用 JavaScript 实现的 MIPS 虚拟机（VM）中运行。该任务包含一条很长的上下游链条：VM 规定了系统调用 ABI 和内存布局，构建必须面向与之兼容的 MIPS ABI，生成的 ELF 还必须放进 VM 中运行以完成验证。正确的分解必须保留连接这些阶段的桥边。

[图 8：make-doom-for-mips 上的真实依赖结构与误预测的依赖结构。]

[¶87]

The error is one omitted bridge edge: the dependency from VM memory layout (step 3) to build configuration (step 6) in the ground-truth dependency structure. In the ground-truth structure, this edge carries the constraint that determines the correct ABI and memory model. In the predicted structure, the edge is absent.

This omission produces a local deadlock. The build agent configures the MIPS toolchain without the VM memory layout, while the validation agent repeatedly rebuilds and waits for a build that satisfies the omitted constraint. Neither agent can break the cycle: the build agent adjusts flags that are not the actual bottleneck, and the validation agent keeps issuing rebuild-and-run cycles.

错误在于遗漏了一条桥边：真实依赖结构中从 VM 内存布局（第 3 步）指向构建配置（第 6 步）的那条依赖。在真实结构中，这条边承载着决定正确 ABI 与内存模型的约束；而在预测结构中，这条边并不存在。

这一遗漏导致了局部死锁。构建智能体在缺少 VM 内存布局信息的情况下配置 MIPS 工具链，而验证智能体则反复重新构建，等待一个满足那条被遗漏约束的构建结果。两个智能体都无法打破这个循环：构建智能体调整的编译选项并不是真正的瓶颈，验证智能体则不停地发起重新构建并运行的循环。

[¶88]

Two costs follow. Communication overhead rises because repeated build-and-run messages do not converge, and redundant execution accumulates because each cycle reruns the same build and the same VM validation.

If the bridge edge is predicted correctly, the build configuration is conditioned on the VM memory layout and syscall ABI, and the correct ABI and soft-float configuration are selected before the first build. The validation stage then observes a consistent ELF, and the trajectory terminates after a small number of build-and-run cycles. This contrast shows why orchestration is naturally formulated as bridge edge prediction: an omitted bridge edge does not merely reduce context cost reduction, but can turn a convergent workflow into a local deadlock.

随之而来的是两项代价：通信开销上升，因为反复的构建并运行消息始终无法收敛；冗余执行不断累积，因为每一轮循环都在重跑同样的构建和同样的 VM 验证。

如果这条桥边被正确预测，构建配置就会以 VM 内存布局和系统调用 ABI 为条件，在第一次构建之前就选定正确的 ABI 与软浮点（soft-float）配置。随后，验证阶段看到的将是一个一致的 ELF，轨迹在少数几轮构建并运行的循环之后即告结束。这一对比说明了为何编排可以自然地表述为桥边预测：遗漏一条桥边不只是削弱上下文成本的降幅，还可能把一个本可收敛的工作流变成局部死锁。

[¶89]

Appendix D Impact Statement

This work studies when multi-agent collaboration is beneficial for long-horizon agentic tasks and when it is not. Its primary impact is conceptual and practical: it clarifies that multi-agent superiority is bounded by task structure rather than universal, and that blindly scaling the number of agents can increase coordination overhead without improving task performance. This message is relevant to practitioners who build agentic systems, since it suggests that collaboration should be introduced selectively, based on the dependency structure of the target task, rather than adopted as a default design choice.

On the positive side, the proposed SAIGE mechanism grows its collaboration graph in response to execution feedback and establishes semantic dependencies through content-based information retrieval. This may help reduce unnecessary context accumulation and improve the reliability of long-horizon execution, which is relevant to applications such as software engineering agents, repository-level code generation, and deep research assistants. By making the cost-performance trade-off of multi-agent decomposition explicit, our analysis may also encourage more disciplined evaluation and reporting practices in this area.

附录 D 影响声明

本文研究多智能体协作在长程智能体任务中何时有益、何时无益。其主要影响体现在概念与实践两个层面：它阐明了多智能体的优势受任务结构约束、并非普遍成立，也表明盲目扩大智能体数量可能徒增协调开销，而无法提升任务表现。这一结论对构建智能体系统的从业者具有参考意义，因为它意味着协作应依据目标任务的依赖结构有选择地引入，而不应被当作默认的设计选择。

从积极的方面看，本文提出的 SAIGE 机制根据执行反馈扩展其协作图，并通过基于内容的信息检索建立语义依赖。这可能有助于减少不必要的上下文累积、提升长程执行的可靠性，对软件工程智能体、仓库级代码生成和深度研究助手等应用具有参考价值。通过明确揭示多智能体分解在成本与性能之间的权衡，我们的分析也可能促使该领域形成更严谨的评估与报告实践。

[¶90]

On the risk side, more capable and autonomous agentic systems can be misused for harmful purposes, including automated exploitation of software vulnerabilities, unauthorized access to computing resources, or large-scale generation of misleading content. The benchmarks used in this work are designed for research evaluation and operate in controlled environments, but the underlying techniques are not inherently restricted to benign settings. Multi-agent decomposition may also introduce failure modes that are harder to audit, such as local deadlocks, mispredicted dependencies, and opaque coordination among agents, which can complicate debugging, accountability, and oversight.

从风险的方面看，能力更强、自主性更高的智能体系统可能被滥用于有害目的，包括自动化利用软件漏洞、未经授权访问计算资源，或大规模生成误导性内容。本文所用的基准专为研究评估而设计，运行在受控环境中，但其底层技术本身并不局限于良性场景。多智能体分解还可能引入更难审计的失败模式，例如局部死锁、依赖误预测以及智能体之间不透明的协调，这些都可能让调试、问责与监督变得更加复杂。