betaFeedback

WorksComputer Science

Goal-Aware Dynamic Multi-Agent Collaboration for Long-Horizon Tasks

Abstract

LLM-based agents are increasingly used to complete complex, long-horizon tasks without human intervention. To make progress toward the task goal, agents need to perform different duties, such as planning and verification, when needed. To understand how single agents manage these duties during long-horizon execution, we conduct a preliminary study. Our analysis shows that verification has the strongest association with task success, but often occurs late, leaving limited opportunities for correction. We also find that the proportion of duty-relevant information decreases as records from different duties accumulate in a shared context. These findings lead us to examine whether multi-agent systems (MAS) can address these problems by assigning duties to agents with separate contexts. Our analysis shows that this separation alone is insufficient. Agents can lose track of the overall goal and repeat prior investigations. They may also lack necessary background while receiving irrelevant information from others. To maintain goal awareness and coordinate collaboration as task needs change, we propose Goal-Aware Dynamic Multi-Agent Collaboration (GAD). It uses a growing execution graph to organize subtasks and their dependencies. To keep agents focused on their goals, each context retains the original instruction and the assigned task's goal and acceptance conditions. To adapt collaboration and information sharing during execution, agents can divide tasks into subtasks and specify dependencies based on execution evidence. These dependencies guide when agents work and which results they receive. Verification and recovery check subtask results and full task completion against their goals, providing feedback for repair when checks fail.

Introduction

LLM-based agents have shown promising capabilities in completing complex tasks without human intervention, particularly on long-horizon tasks [9, 18]. These tasks can span hundreds of interaction steps, during which agents repeatedly interact with the environment and adapt their actions based on feedback [11, 12]. To guide this process toward successful completion, agents often need to perform various duties, such as planning, reasoning, verification, and functional responsibilities [1, 5, 8], as needed throughout execution. For example, a web research agent first plans what information to search for [10], then reasons over the retrieved evidence [8], before verifying whether the evidence supports its answer [1]. Analysing these duties is crucial to understand agent trajectories. If an agent cannot allocate and switch duties when needed, it may continue executing outdated plans or leave errors unchecked [12]. Therefore, it is important to understand how agents manage these duties during long-horizon execution.

However, allocating duties effectively by a single agent can be challenging. In § 2.1, we perform a preliminary study to examine how agents manage these duties. Our analysis reveals two key limitations: (1) Among all duties, verification exhibits the strongest association with task success, yet often occurs late in the task process. Intuitively, early verification of an interaction result can help agents detect and correct errors before they propagate into subsequent actions. However, agents may continue working on the task without performing the duty of verification, leaving errors undetected and limiting opportunities for correction. (2) Agents may struggle to retrieve relevant evidence and prior decisions for the current duty from the extensive accumulated context. Our context analysis shows that as records from different duties accumulate in a shared context, information relevant to the current duty accounts for a decreasing proportion of the interaction history. These two findings motivate us to investigate whether explicitly assigning distinct duties to separate agents using multi-agent systems (MAS)

CCS Concepts

• Computing methodologies → Artificial intelligence. can address these limitations by maintaining separate contexts and enabling verification when needed.

However, the naive adoption of MAS does not resolve the limitations of single-agent execution. In § 2.2, we evaluate six representative multi-agent configurations on duty performance using the same trajectory analysis approach. Our analysis identifies two limitations. (1) Agents can lose track of the overall goal. They might repeat investigations that others have already attempted, spending additional steps without advancing the task. (2) Separate contexts do not automatically improve information management. Agents may lack the background or conditions needed for their duties, while messages from other agents may add irrelevant information to their contexts. These findings highlight that throughout long-horizon execution, maintaining goal awareness and dynamically coordinating duties and information exchange are important.

Motivated by these findings, we propose Goal-Aware Dynamic Multi-Agent Collaboration (GAD) for long-horizon tasks. GAD uses a growing execution graph to organize subtasks and guide information sharing during execution. Each node represents an assigned task, while edges record task decomposition and dependencies. To prevent goal drifting, we retain the original instruction and the assigned task’s goal and acceptance conditions in each agent’s context. Each task also retains its goal and the duty to satisfy it as the graph expands. To support dynamic collaboration, agents can divide their assigned tasks into subtasks and specify dependencies based on execution evidence. These dependencies guide agent scheduling and dependency-aware context construction to supply relevant results. Verification and recovery check both subtask results and full task completion against their goals and acceptance conditions, providing feedback for repair when checks fail. We conduct experiments on Terminal-Bench 2.1 and SWE-bench Pro Hard-51 with Claude Sonnet 4.6 and Qwen3.7-Plus, demonstrating performance improvements over the evaluated baselines. Further analyses support component effectiveness and show lower token costs than multi-agent baselines on jointly solved tasks.

Related Work

Long-Horizon Agents

Recent research improves long-horizon agents through supervised fine-tuning and multi-turn reinforcement learning. The former trains agents on synthetic interaction trajectories [23, 24, 30], while the latter develops decision-making policies through feedback from real or synthesised environments [2, 19, 20, 22]. These approaches improve agent behaviour through training, but extended execution also requires managing accumulated information and tracking task progress. MEM1 jointly learns reasoning and compact memory updates [29]. ReSum summarises interaction histories to support continued search [21], while Context-Folding trains agents to handle subtasks in separate trajectories and retain their summaries [16]. LongHorizon-Harness further separates task management, execution, and auditing to maintain independently checked progress [12]. Our method complements policy training by organising collaboration during execution. It connects agent-proposed subtasks, dependency-guided information sharing, and verification through a growing execution graph, while retaining the task goal.

Multi-Agent Systems

Multi-agent collaboration has developed from predefined role procedures towards automatically constructed collaboration structures [7]. GPTSwarm optimises agent prompts and graph connections [31], G-Designer learns task-dependent topologies [27], and AFlow searches executable workflows [28]. Graph-of-Agents further selects relevant models and structures their exchanges for each query [26]. Alongside structure design, another research direction coordinates agents during execution. Magentic-One uses a central orchestrator to track progress and delegate tasks [6]; Evolving Orchestration learns agent-selection policies [3], and AOrchestra creates specialised subagents on demand [15]. Self-Organizing Agent Teams also retains collaboration experience as reusable organisational strategies [14]. We examine these concerns through duty allocation and information use, then connect agent-proposed decomposition with dependency-guided execution and verification without a central LLM orchestrator.

Preliminary study

Long-horizon tasks require agents to execute autonomously with limited human intervention and take on different duties as execution needs change. We first examine how single agents allocate these duties and use their shared history to obtain relevant information (§ 2.1). We then study whether assigning duties to separate agents with their own contexts improves duty organisation and information use (§ 2.2).

Task setting. We study long-horizon tasks specified by a natural-language instruction II and an initial environment state s0s_0. An agent uses a policy π\pi to select actions based on the instruction and its available context, receiving observations from the environment after each action. A harness manages tool execution, context construction, and termination. In a multi-agent system, it also determines when each agent acts and what information it receives. We evaluate task performance using an external verifier VV after execution stops; during execution, agents rely on environment observations and their own checks without access to feedback from VV. We examine how single-agent and multi-agent systems allocate duties and use information over extended interactions.

Auditing long-horizon loops by single agents

A long-horizon task requires an agent to perform different duties at different stages of execution. Effective duty allocation is important for detecting errors in time and maintaining progress toward the task goal. In this section, we examine how a single agent manages these duties. Our analysis focuses on two aspects. First, we analyze how verification relates to task success and when it occurs during execution. Second, we examine how information relevant to the current duty is represented in the growing interaction history. Specifically, we first introduce the experimental setup, then present these two analyses and summarize the main findings.

Setup. We audit 193 trajectories, comprising 4,842 agent steps, on a 45-task subset of Terminal-Bench 2 whose difficulty composition follows that of the full benchmark (4 easy, 26 medium, 15 hard). We use three harnesses with Claude Opus 4.6 (Terminus KIRA, a ReAct-based loop, and Terminus 2), and three base models with the ReAct loop (Claude Opus 4.6, Claude Sonnet 4.6, and Qwen3.7-Plus). We use another LLM (GPT-5.5) to attribute the content an agent produces at each step, both its stated reasoning and the action it chose, to one of six responsibilities: planning, acting, interpreting an observation, verifying, self-correcting, and working off-task. Content that fits none of them falls into a seventh, unclassified category. Appendix A gives the per-configuration tables and the measurement details. We summarize the experimental results and observations as follows.

1. The agent spends the least on verification and leaves it to the end, although verification is highly related to task success. As shown in Figure 1a, verification is the smallest of the main duties (those above 10% of the output), taking at most 14% of the agent’s output. Figure 1b shows that it is also the last duty to appear. It is nearly absent early in a trajectory and peaks in the final segment. The agent thus uses verification mainly as a final verify before it stops, rather than interleaving it with execution. Besides, Figure 1c also shows that the pass rate rises from 36% in the lowest-verification group to 74% in the highest. No passing trajectory skips verification. These results suggest that verification is closely associated with task success, making its limited and late allocation notable. Verifying more is still not sufficient, since about a quarter of the trajectories in the highest group fail.

Figure 1. (a) Output share by duty; labels show the fraction of adjacent steps with different dominant duties. (b) Planning (dashed) and verification (solid) output shares across trajectory positions, coloured by configuration. (c) Pass rates for three equal-sized groups ranked by verification share, pooled across configurations; labels show passing/total trajectories. (d) Prior steps needed (dark) or not needed (light) by the current duty; labels show the needed fraction.

2. The context mixes all duties, and the proportion relevant to each duty falls as the trajectory grows. A single agent keeps the history of all its duties in one context. To measure how much of this context the duty of a given step actually needs, we sample steps from every configuration and ask the judge to mark the previous steps whose content this duty requires. A previous step counts as relevant only if its content is needed, not merely because it performs the same type of duty. As shown in Figure 1d, the number of previous steps grows from about 5 to about 30 over a trajectory. In contrast, the number of relevant steps grows only from 1.4 to 3.0.

As a result, the proportion of relevant context falls from 33% to 14%. Each duty has to find what it needs among the growing amount of content produced for other duties. We argue that giving each duty its own context would potentially prevent this, and verify whether it is effective in § 2.2.

Discussion. Our study identifies two key limitations of single-agent execution. First, verification often occurs late, despite its strong association with task success, limiting opportunities for correction. Second, records from different duties accumulate in a shared context, reducing the proportion of information relevant to the current duty. This may make it harder for agents to locate the evidence and prior decisions they need. These findings raise a natural question: Can explicitly assigning different duties to separate agents, each with its own context, improve duty allocation and access to relevant information?

Can multi-agent systems supply what a single agent lacks?

In this section, we answer the above question and explain why assigning duties to separate agents with their own contexts does not by itself resolve the limitations of single-agent execution. Our analysis examines two possible reasons. First, we investigate whether individual agents remain aligned with the overall task objective during collaboration. Second, we examine whether information sharing provides each agent with the background and results needed for its duties. Specifically, we first introduce the experimental setup, then present these two analyses and summarize the main findings.

Setup. We use the same 45-task subset of Terminal-Bench 2 as in Section 3.1, and the same policy model Claude Sonnet 4.6. We evaluate six multi-agent paradigms: a MetaGPT-style role pipeline, three static communication topologies (chain, star, and fully connected), a Magentic-One-style orchestrator, and Anthropic-style subagents. With the single-agent baseline, this gives seven configurations. We judge each step with GPT-5.5, using the same responsibility audit as that in § 2.1, now applied to each agent separately. We summarize the experimental results and observations as follows:

  1. Fixed roles fail to keep agents aligned with the overall task objective. Multi-agent systems rely on collaboration among agents, yet such collaboration does not necessarily ensure that individual agents remain aligned with the overall task objective. To investigate this issue, we employ a judge to evaluate each agent’s execution history and determine whether each step contributes to progress toward the overall goal. As shown in Figure 2a, multi-agent systems exhibit off-track behavior 2–5 times more frequently than the single agent. Nearly all off-track steps involve repetitive actions that have already been attempted, indicating that agents become trapped in unproductive cycles. This behavior stems from the rigid organization of existing multi-agent systems: agent roles and execution order are predefined before the task is fully understood, while individual agents operate in isolation without monitoring overall task progress. These systems lack the mechanisms to dynamically adapt agent responsibilities based on feedback from task execution.

Figure 2. (a) Off-track score of action steps for each system, judged against the original goal. Labels give the ratio to the single agent. (b) Fraction of messages between agents that are irrelevant to the receiving agent. (c) Tool-error rate of delegated agents in their first two steps (dark) and in later steps (light).

  1. Agents lack awareness of one another’s information needs, leading to ineffective information exchange. In multi-agent systems, each agent maintains its own context and exchanges messages with other agents to facilitate collaboration. However, we find that 4%–30% of the exchanged messages are irrelevant to their receivers, with systems employing more aggressive message compression exhibiting the highest irrelevance rates (Figure 2b). This inefficiency arises because senders lack awareness of the information needs of their receivers. While message summarization reduces context consumption, it may also discard critical information required by downstream agents. Furthermore, newly delegated agents often lack sufficient background information to perform their assigned tasks effectively. As shown in Figure 2c, their first two execution steps exhibit failure rates up to 2.3 times higher than those of subsequent steps. Both observations highlight a fundamental limitation: existing systems lack mechanisms for agents to identify and communicate their information needs. Effective

multi-agent collaboration therefore requires explicitly modeling information dependencies among agents and enabling information exchange based on these dependencies.

Discussions. The above analysis reveals two critical capabilities missing from existing multi-agent systems for long-horizon tasks. The first is goal awareness, which requires agents to continuously align their actions with the overall task objective and verify their progress toward that objective throughout execution. Existing systems lack mechanisms to monitor overall task progress, allowing agents to deviate from the goal and repeatedly perform unproductive actions. The second is dynamic collaboration, which requires agents to adapt their responsibilities and information exchange based on the evolving needs and dependencies revealed during task execution. Existing systems instead rely on predefined roles and communication structures, preventing agents from performing the right duties at the right time and exchanging the information needed for effective collaboration. Together, goal awareness and dynamic collaboration are essential for multi-agent systems to successfully execute long-horizon tasks.

Method

As discussed in the previous section, effective long-horizon collaboration requires goal awareness to keep local tasks aligned with the overall objective, and dynamic collaboration to adapt the division of duties and information sharing to execution needs. To provide these capabilities, we propose Goal-Aware Dynamic Multi-Agent Collaboration (GAD). Our framework builds on a growing execution graph that starts from the original task and expands through agent-proposed subtasks and dependencies. Throughout expansion, each node retains its goal and the duty to satisfy it. We first present this graph and its execution loop in § 3.1. We then introduce two supporting mechanisms in § 3.2: dependency-aware context construction supplies relevant information for node execution, while verification and recovery check results and provide feedback for further execution. Figure 3 illustrates how decomposition expands the graph and verified results allow execution to continue toward integration and final verification of the original task.

Figure 3. Overview of GAD. (1) Execution starts from a root node representing the original task. (2) Agents propose subtasks and dependencies as execution needs emerge; the controller validates these requests before expanding the graph. (3) Execution follows dependencies until the root integrates the results and passes its own verification.

The Main Framework: Growing Execution Graph

To support goal awareness and dynamic collaboration, we use a growing execution graph to organise task goals and dependencies. The graph adapts to emerging execution needs while retaining each node’s goal and the duty to satisfy it. In the rest of this subsection, we first define the graph and explain how execution starts from the root. We then introduce agent-proposed decomposition and the controller’s validation and graph updates. Finally, we describe the execution loop and how it returns to the original task for integration and completion.

Notations. To represent task goals and their dependencies as collaboration develops, we maintain an execution graph Gt=(Nt,Et)G_t = (N_t, E_t), where tt indexes scheduling steps. Each node vv represents an assigned task and stores its specific goal gvg_v, acceptance conditions KvK_v that determine whether the goal has been achieved, and an execution status σv\sigma_v. Edges connect a task to its subtasks, or to another task whose verified result it requires.

Step 1. Starting from the root. Initially, N0={vroot}N_0 = \{v_{\mathrm{root}}\}, E0=∅E_0 = \varnothing, and gvroot=Ig_{v_{\mathrm{root}}} = I. We include full satisfaction of II as the root’s acceptance condition and then launch an agent whose initial context contains the instruction, this completion requirement, and the root’s status. The graph has not yet expanded, so the root has no dependency results to draw on. Its execution history starts empty and accumulates observations as the agent interacts with the environment. These records guide subsequent actions without requiring a complete workflow in advance. The agent starts by interacting directly with the environment and uses the resulting observations to guide subsequent actions, without constructing a complete workflow in advance.

Step 2. On-demand recursive decomposition. As agents execute their assigned tasks, new observations may reveal needs for additional subtasks. To adapt the division of duties to these needs, we allow each executing agent to request decomposition. We describe when the agent makes this decision, what it submits, and how the controller uses the request to update the graph.

  • When to decompose. We use on-demand decomposition to adapt the division of duties to needs that emerge during execution. The agent executing each node decides whether to introduce subtasks, without relying on a central LLM orchestrator or a predefined communication topology. We prompt the agent executing node vv to express its next decision as a structured action ut,vu_{t,v}. The core action types are

Ucore={RUN,DECOMPOSE,SEARCH,VERIFY}.(1)\mathcal{U}_{\mathrm{core}} = \{\mathrm{RUN}, \mathrm{DECOMPOSE}, \mathrm{SEARCH}, \mathrm{VERIFY}\}. \tag*{(1)}

These actions respectively execute an environment command, request decomposition, retrieve shared artifacts, and request verification. When type⁡(ut,v)=DECOMPOSE\operatorname{type}(u_{t,v}) = \mathrm{DECOMPOSE}, the agent prepares a decomposition request as follows.

  • Submitting decomposition requests. The agent submits a request

dv=({(ℓi,gi,Ki,Pi)}i=1m,Jv),(2)d_v = \left(\{(\ell_i,g_i,K_i,P_i)\}_{i=1}^{m},J_v\right), \tag*{(2)}

where ℓi\ell_i identifies a proposed subtask and gig_i its goal. The acceptance conditions KiK_i specify its completion requirements, which we assess through the verification scheme in Section 4.2. The dependency set PiP_i lists the subtasks or existing nodes whose verified results it requires. These dependencies guide the supply of results to its execution context through the scheme in Section 4.2.1. The set JvJ_v references previous execution steps recorded at vv, grounding the decomposition in execution evidence. The agent submits dvd_v to the controller for validation.

  • How to update the graph. Once an agent submits a decomposition request dvd_v, we need to determine whether it can extend the graph and how execution should proceed after the update. We introduce a lightweight, rule-based harness controller H\mathcal{H} to validate the request and apply graph updates without additional model inference. It checks dvd_v against the current graph, the node-specific execution history hvth_v^t, and the remaining resource budgets BtB_t:

(bv,fv)=Check⁡H(dv,Gt,hvt,Bt),(3)(b_v,f_v) = \operatorname{Check}_{\mathcal{H}}(d_v,G_t,h_v^t,B_t), \tag*{(3)}

where bv∈{0,1}b_v \in\{0,1\} indicates whether the request is accepted and fvf_v provides feedback. The checks require at least one valid reference to an execution step of vv, valid subtask and dependency specifications, compliance with resource limits, and an acyclic resulting graph. If bv=0b_v = 0, the graph remains unchanged and the agent receives fvf_v to revise its next action. Otherwise, H\mathcal{H} creates or reuses compatible child nodes CvC_v, resolves the references in PiP_i into dependency edges DvD_v, and updates the graph:

Nt+1=Nt∪Cv,Et+1=Et∪{(v,c):c∈Cv}∪Dv.(4)\begin{aligned} N_{t+1} &= N_t \cup C_v,\\ E_{t+1} &= E_t \cup\{(v,c):c \in C_v\} \cup D_v. \tag*{(4)} \end{aligned}

Here, (x,y)∈Dv(x,y) \in D_v means that xx requires the verified result of yy. The child set forms a new route ρv,k=Cv\rho_{v,k} = C_v, where kk indexes alternative approaches to achieving gvg_v. Node vv waits while the route remains unresolved. To maintain goal awareness during graph expansion, we keep gvg_v and its full-goal acceptance condition unchanged, with the root goal remaining II. Even when a route completes, node vv must still pass verification against its original goal gvg_v.

Step 3. Execute in a loop until completion. After updating the graph, H\mathcal{H} selects nodes for subsequent execution. The controller tracks each node’s status through four core states:

σv∈{READY,ACTIVE,WAITING,VERIFIED}.(5)\sigma_v \in\{\mathrm{READY},\mathrm{ACTIVE},\mathrm{WAITING},\mathrm{VERIFIED}\}. \tag*{(5)}

These indicate that a node can execute, is currently executing, awaits required results, or has passed verification, respectively. The controller updates these states from dependency and route outcomes and identifies the nodes still needed for the root task, denoted by NtneededN_t^{\mathrm{needed}}. It constructs the execution frontier

Ft={v∈Ntneeded∣σv=READY}.(6)\mathcal{F}_t = \{v \in N_t^{\mathrm{needed}} \mid\sigma_v = \mathrm{READY}\}. \tag*{(6)}

For each selected node, H\mathcal{H} launches an agent with a local context constructed through our dependency-guided scheme in § 3.2.1. This context supplies the recorded observations and relevant results needed to continue the assigned task. The agent executes its task, requests decomposition, or requests verification as described in § 3.2.2. As execution changes the graph and node states, H\mathcal{H} recomputes the frontier and repeats this process.

A node becomes ready once its required dependencies are verified. When a route completes and the other dependencies of node vv are satisfied, vv resumes to integrate the results and pass its own verification. If all its routes fail, vv can resume to attempt another approach. The system declares task completion only when the root passes verification against the original instruction II and all acceptance conditions in KvrootK_{v_{\mathrm{root}}}. This can follow direct execution or subtask integration. Execution also stops when the budget runs out or no nodes can execute and no agents remain active, but these cases do not establish task completion.

Supporting Mechanisms: Context Construction and Verification

To support execution of the growing graph, we need to provide agents with relevant information and assess whether their results satisfy the assigned goals. We introduce two supporting mechanisms: dependency-aware context construction supplies the inputs for each node’s execution, while verification and recovery check its results and provide feedback for further execution. We describe these mechanisms in § 3.2.1 and § 3.2.2, respectively.

Dependency-Aware Context Construction

As mentioned in § 3.1, the execution graph determines which nodes can execute next. The agents launched for these nodes also need relevant background and results to continue execution. Our analysis in § 2.2 shows that agents can lack this information or receive messages unrelated to their needs. We address this gap through two complementary mechanisms: dependency-based sharing provides verified results from declared dependencies, while dependency-free retrieval supplies additional information without requiring explicit dependency links.

Context formulation. We maintain a shared collection of results Rt\mathcal{R}_t, where the agent executing each node can contribute findings with references to supporting execution steps. To share these findings without copying the contributing agent’s full history, the controller selects relevant results and combines them with the node’s task information and execution records. For node vv, this gives the context

ct,v=(I,gv,Kv,Lt(v),Rtdep(v),Rtret(v)),(7)c_{t,v} = \left(I,g_v,K_v,\mathcal{L}_t(v),\mathcal{R}^{\mathrm{dep}}_t(v),\mathcal{R}^{\mathrm{ret}}_t(v)\right), \tag*{(7)}

where Lt(v)\mathcal{L}_t(v) contains recent execution records, the node’s own results, and information about the task that introduced vv, its dependencies, and its routes. These records support continued execution, while II, gvg_v, and KvK_v retain the overall goal and current task requirements. Given ct,vc_{t,v}, the agent generates its next structured action as ut,v∼π(⋅∣ct,v)u_{t,v} \sim\pi(\cdot\mid c_{t,v}), following (1).

Dependency-based sharing. The controller uses node vv’s declared dependencies to identify the results it requires. It directly includes verified results from these dependencies in Rtdep(v)\mathcal{R}^{\mathrm{dep}}_t(v). This connects the dependencies proposed during decomposition to the information available during subsequent execution.

Dependency-free retrieval. Declared dependencies may not cover all the information needed for the next action. The controller supplements these inputs with relevant results retrieved from Rt\mathcal{R}_t, denoted by Rtret(v)\mathcal{R}^{\mathrm{ret}}_t(v). Retrieval does not require an explicit dependency link to vv. When the agent needs further information, it can autonomously output a SEARCH action with a query. The controller includes the retrieved results in the next context for vv.

Verification and Recovery

As mentioned in § 3.1, verified node results allow subsequent tasks to proceed and enable result integration. This requires checking whether each node has satisfied its goal when its agent requests completion. Our analysis in § 2.1 shows that agents often defer verification until late in execution, leaving little opportunity to repair errors. We address this issue through two stages: node verification combines executable checks with an independent semantic review to assess completion; result acceptance and repair uses this assessment to accept the result or return feedback for further execution.

Node Verification. When the agent executing node vv outputs VERIFY, the controller runs the executable checks in KvK_v and appends their observations to htvh^v_t. Let mv=1m_v = 1 indicate that all these checks pass. The controller then invokes a semantic verifier with a fresh context:

qv={Audit⁡π(v),mv=1,0,otherwise.(8)q_v = \begin{cases} \operatorname{Audit}_{\pi}(v), & m_v = 1,\\ 0, & \text{otherwise}. \end{cases} \tag*{(8)}

Here, Audit⁡π(v)∈{0,1}\operatorname{Audit}_{\pi}(v) \in\{0,1\} assesses whether the execution evidence and verified dependency results support gvg_v and every acceptance condition in KvK_v. The verifier must address each condition and cite supporting evidence. When no executable check applies, we set mv=1m_v = 1 and assess the recorded evidence directly. This internal review differs from the external task verifier VV, which evaluates the final environment after execution stops.

Result Acceptance and Repair. If qv=1q_v = 1, the controller sets σv=VERIFIED\sigma_v = \mathrm{VERIFIED} and adds an evidence-linked result to RtR_t for subsequent dependency contexts. Otherwise, it returns the failed check or review feedback to node vv for continued execution and repair. A rejected verification does not by itself fail the route. Both outcomes return to the execution loop in § 3.1. The pseudo-code algorithm of GAD is provided in Appendix § 8.

Experiments

In this section, we first describe the experimental setup in § 4.1 and present the main results in § 4.2. We then conduct ablation studies in § 4.3. Next, we evaluate how our approach addresses the two limitations of MAS in § 4.4. Finally, we analyze its computational efficiency in § 4.5.

Experimental Setup

Datasets. We evaluate GAD on two challenging benchmarks, namely Terminal-Bench 2.1 [13] and the Hard-51 subset of the SWE-Bench Pro V2 [4]. Specifically, Terminal-Bench 2.1 contains 89 tasks covering diverse terminal operations. Hard-51 contains 51 challenging repository-level software engineering tasks. We report task resolution rates using the benchmark verifiers. For SWE-Bench Pro, we evaluate generated patches in fresh environments following the official protocol.

Baselines. Our single-agent baselines include the following three methods: ReAct based loop [25], Terminus-KIRA, Terminus-2. For static multi-agent collaboration, we compare Chain, Star, Full [27], MetaGPT [7], and Mixture-of-Agents [17]. For dynamic collaboration, we include Subagents, Magentic-One [6], and LongHorizon-Harness [12] with ReAct and Claude Code backends.

Implementation details. We use Claude Sonnet 4.6 and Qwen3.7-Plus as the base models. We run tasks in containerised environments, with Docker as the default backend. Our method uses the same base model for node execution and semantic verification. We allow up to three concurrent workers per task and include the seven most recent node execution records in each local context. We retrieve up to six shared results per query. Our method permits up to 1,000 tool calls and 2,000 model calls per task, without an aggregate token limit. The wall-clock limit is 18,000 seconds on Terminal-Bench; the available Hard-51 runs use 3,000 or 4,500 seconds. Appendix § 9 provides the detailed settings.

Main Results

In this section, we compare GAD with three single-agent harnesses and nine multi-agent systems. Table 1 reports the resolution rates. The main findings are as follows.

CategoryMethodTerminal-Bench 2.1 Sonnet 4.6Terminal-Bench 2.1 Qwen3.7-PlusSWE-Bench Pro (Hard-51) Sonnet 4.6SWE-Bench Pro (Hard-51) Qwen3.7-Plus
Single agentSingle (React loop)57.356.227.531.4
Single (Terminus-KIRA)41.641.649.031.4
Single (Terminus-2)52.855.064.727.5
Static MAS (fixed topology)Chain58.451.739.225.5
Static MAS (fixed topology)Star56.252.843.115.7
Static MAS (fixed topology)Full56.249.439.223.5
Static MAS (fixed topology)MetaGPT46.151.731.429.4
Static MAS (fixed topology)Mixture-of-Agents40.451.713.725.5
Dynamic MAS (adaptive)Subagents52.851.717.627.5
Dynamic MAS (adaptive)Magentic-One36.048.327.525.5
Dynamic MAS (adaptive)LongHorizon-Harness (React loop)57.356.211.817.6
Dynamic MAS (adaptive)LongHorizon-Harness (Claude code)65.257.3–†–†
OursGAD71.964.066.733.3

Table 1. Task resolution rate (%) on Terminal-Bench 2.1 and SWE-Bench Pro Hard-51 and all methods with same execution budget. †LongHorizon-Harness drives Claude code is incompatible with SWE-Bench Pro’s no-network agent policy.

GAD consistently outperforms the single-agent harnesses. As shown in Table 1, GAD achieves the highest resolution rate across all benchmarks and base models. Compared with the strongest single-agent harness in each setting, it improves resolution rates on Terminal-Bench 2.1 by 14.6 and 7.8 percentage points under Sonnet 4.6 and Qwen3.7-Plus, respectively. The corresponding gains on Hard-51 of SWE-Bench Pro are 2.0% and 1.9%. The improvements are larger on Terminal-Bench, while the strongest single-agent harness remains competitive on Hard-51. We suggest that these improvements result from separating local task execution from independent verification, so checking does not rely solely on the executing agent’s own duty allocation. Node-specific contexts also let agents continue from relevant records without recovering their task state from the mixed history of all duties.

GAD achieves higher resolution rates than existing multi-agent designs. As shown in Table 1, GAD exceeds the strongest MAS baseline by 6.7% and 6.7% on Terminal-Bench 2.1, and by 23.6% and 3.9% on Hard-51, under two base model, respectively. The baseline results also show that multi-agent designs do not consistently outperform single-agent harnesses, and dynamic designs do not always improve over fixed topologies. These observations support our preliminary finding that separating duties across agents alone does not ensure effective collaboration. We suggest that these improvements result from adapting the division of duties to execution needs while retaining the original goal and each node’s acceptance conditions. Explicit dependencies also connect task scheduling with the results each agent receives, addressing the missing background and irrelevant information exchange observed in existing MAS.

In summary, we suggest that these gains result from on-demand decomposition, which lets agents focus on subtasks revealed during execution, and dependency-aware context construction, which provides the prior results needed to continue without repeating earlier investigations.

Ablation Studies

We ablate goal awareness by removing goal-related tracking mechanisms, and dynamic collaboration by disabling helper requests, inter-agent dependency requests, and decomposition. We then isolate the contribution of decomposition on tasks where GAD activates it. The main findings are as follows.

Both goal awareness and dynamic collaboration contribute to performance. As shown in Table 2, removing either component lowers the resolution rate in all four settings. With Sonnet 4.6 on SWE-Bench Pro, the resolution rate falls from 66.7% to 58.8% without goal awareness and to 52.9% without dynamic collaboration. With Qwen3.7-Plus on Terminal-Bench 2.1, removing goal awareness leads to a larger drop than removing dynamic collaboration, with resolution rates of 60.7% and 61.8%, respectively. These results suggest that the two components contribute in different ways. Goal awareness applies throughout execution, whereas decomposition changes the task structure only when an agent requests it. Qwen3.7-Plus decomposes only 2 of the 89 Terminal-Bench 2.1 tasks, which limits the contribution of decomposition in this setting.

MethodSonnet 4.6 TB2.1Sonnet 4.6 Hard51Qwen3.7-Plus TB2.1Qwen3.7-Plus Hard51
GAD71.9 (64)66.7 (34)64.0 (57)33.3 (17)
w/o goal awareness69.7 (62)58.8 (30)60.7 (54)27.5 (14)
w/o dynamic collaboration67.4 (60)52.9 (27)61.8 (55)23.5 (12)

Table 2. Ablation of GAD. Pass rate (%) in brackets

On-demand decomposition improves task success. We select the tasks that GAD decomposes in its full configuration and rerun the same tasks with decomposition disabled. Each task must then proceed through the root node without creating subtasks. As shown in Figure 4a, the number of solved tasks falls from 7 to 3 among the 15 selected Terminal-Bench 2.1 tasks, and from 15 to 10 among the 24 selected SWE-Bench Pro tasks. These results suggest that decomposition contributes to success on tasks where GAD chooses to introduce subtasks.

Figure 4. (a) Pass rate on the decomposed tasks, with and without decomposition. (b) Fraction of steps that leave the assigned subgoal. (c) Tool-error rate of a new agent in its first two steps and later. (d) Each row compares GAD (orange) with one baseline (blue) on the tasks both solve. Dots show median tokens per task; baseline counts indicate task numbers.

Improvement on the two limitations in MAS

To examine whether GAD provides the goal awareness and dynamic collaboration that existing multi-agent systems lack, we audited its trajectories with the procedure of § 2.2. GAD decomposes seven of the 45 Terminal-Bench 2.1 tasks. Only these trajectories involve more than one agent, so the analysis uses these seven tasks. All systems run on Sonnet 4.6.

Agents in GAD stay on the subgoals they are assigned. As shown in Figure 4b, when each execution step is judged against the subgoal assigned to the agent that took it, only 10.2% of the steps of GAD leave their subgoal. The rate is 14.9% for subagents and 37.7% for MetaGPT. We suggest that a subgoal formed from execution gives each agent a clear target, because it carries its own acceptance criteria. Each agent thus keeps its work tied to the goal.

Agents in GAD start working as soon as they are assigned. As shown in Figure 4c, 10.1% of the first two steps of a newly assigned agent in GAD end in a tool error. Its later steps fail at a similar rate of 9.8%. In chain, the first two steps fail in 35.7% of cases, twice its later rate of 17.6%. We suggest that GAD gives each agent the verified results of the subgoals it depends on. The agent thus starts from what is already known and does not need to explore the environment first.

Efficiency Analysis

We measure cost by the tokens a system consumes on a task. The count adds the input and output tokens of every LLM call made by every agent in the system, including the calls GAD makes for verification. The main findings are as follows. GAD solves the same tasks at lower cost. We compare each baseline with GAD on the tasks both systems solve, and report the median token usage. As shown in Figure 4d, on Terminal-Bench 2.1 with Sonnet 4.6, GAD needs about 50k tokens per task. Multi-agent systems need 105–170k on the same tasks, and the long-horizon harness needs 2.6M. We suggest that the cost of existing multi-agent systems comes from coordination that they pay regardless of the task. GAD adds structure only when the goal requires it. On simple tasks it runs like a single agent, so its cost matches the single agent and stays below systems that coordinate on every task. Its accuracy gain does not come from spending more computation.

Conclusion

Long-horizon tasks require LLM agents to manage multiple duties throughout repeated interactions with the environment. Our analysis shows that verification has the strongest association with task success but often comes late, while the proportion of duty-relevant information decreases as the context grows. Existing multi-agent systems can lose track of the overall goal, and context separation alone does not ensure effective information sharing. We propose GAD to maintain goal awareness and organize collaboration as execution reveals new needs. It retains the original instruction and assigned task goals and acceptance conditions in each agent’s context. A growing execution graph guides scheduling and information sharing as agents divide tasks and specify dependencies during execution. Verification and recovery check both subtask results and full task completion, providing feedback for repair. Experiments with Claude Sonnet 4.6 and Qwen3.7-Plus on Terminal-Bench 2.1 and SWE-bench Pro Hard-51 show gains of up to 6.7 percentage points over the strongest baseline.

References

Details of the Audit

Configurations. We audit five configurations on the 45-task subset of Terminal-Bench 2 (4 easy, 26 medium and 15 hard tasks). The first three vary the harness with Opus 4.6 fixed. The last three vary the model with ReAct fixed. Trajectories whose verifier did not run are excluded, since they are neither passes nor failures. Table 3 lists the trajectories that remain.

ModelHarnessTrajectoriesStepsPass rate (%)
Opus 4.6Terminus-KIRA43154462.8
Opus 4.6ReAct44126243.2
Opus 4.6Terminus-22941841.4
Sonnet 4.6ReAct3245662.5
Qwen3.7-PlusReAct45116260.0

Table 3. Audited single-agent configurations.

Duty attribution. A judge splits the content each step generates into the seven duties of Table 4, as fractions that sum to one. The judge sees the task instruction and, for each step, the agent’s reasoning, its command and the resulting observation. Our own step labels are not shown, since they would reveal the answer. Table 5 gives the settings.

DutyDefinition
plandeciding what to do next, ordering subgoals, tracking the objective
actissuing the command, or writing the code it contains
interpretreading and making sense of the previous observation
verifychecking whether the result meets the acceptance criteria
self-correctdiagnosing an earlier mistake and recovering from it
off-taskcontent unrelated to the task, or repeating covered ground
otherlegitimate content that fits none of the above

Table 4. Duties used in the audit.

SettingValue
Judge modelGPT-5.5, temperature 1.0
Steps per call5
Text per stepreasoning 900, command 600, observation 400 characters
Task instruction1500 characters
Dominant dutyduty with the largest fraction
Duty-switch rateshare of adjacent steps with different dominant duties
Positionfive equal trajectory segments
Verification groupsthirds by verification share, pooled
Confidence intervals2000 bootstrap draws over trajectories

Table 5. Judge and metric settings.

Context relevance. We sample 30 steps from each configuration, 6 from each of the five trajectory segments. A sampled step lies in a trajectory of at least six steps and has at least three steps before it. The judge sees the task, the current step and every earlier step with its observation. It lists the earlier steps whose content the current step needs. A step on the same topic or of the same duty is not listed unless its content is needed. The reported share is the number of listed steps over the number of earlier steps. Earlier observations are cut to 8000 characters, the length the harnesses keep in context, and the rendered history to 60000 characters.

Pseudo-code for GAD

Algorithm 1 presents the core workflow of GAD in sequential form. Lines 1–2 initialize the graph, shared results, environment, and root task. At each iteration, Lines 4–9 update node states, check stopping conditions, select a ready node, and generate an action from its local context. Lines 10–18 handle environment execution, decomposition, and retrieval. An accepted decomposition expands the graph, while a rejected request returns feedback. Lines 19–22 check node completion and either publish a verified result or retain feedback for repair. Line 24 returns a node to READY if it remains ACTIVE. The loop stops when the root passes verification, the budget runs out, or no ready nodes remain. Only root verification establishes task completion. In concurrent execution, the controller waits for running agents before treating an empty frontier as a stopping condition.

Implementation Details

We use Claude Sonnet 4.6 and Qwen3.7-Plus as the base models, with the same model for node execution and semantic verification within each setting. Tasks run in containerized environments, with Docker as the default backend. Table 6 summarizes the reference Growing-DAG V1.1 configuration. All methods use the same per-task execution budget within each evaluation setting. For Growing-DAG, tool and model-call budgets are shared by all workers within a task, and verification commands count toward the tool-call budget. No aggregate token limit is imposed. The working deadline is 18,000 seconds for Terminal-Bench and 3,000 or 4,500 seconds for Hard-51, depending on the evaluation setting. Additional harness time for cleanup and patch capture does not extend the model’s working deadline.

HyperparameterValue
Concurrent workers3
Recent local records (worker / verifier)7 / 10
Retrieved artifacts per query6
Maximum nodes / depth64 / 8
Maximum children per route4
Maximum routes per node3
Reuse candidate similarity threshold0.72
Temperature (worker / verifier)0.1 / 0.0
Initial output tokens (worker / verifier)8,192 / 4,096
Tool / model calls per task1,000 / 2,000
Aggregate token budgetUnlimited
Working deadline: Terminal-Bench (s)18,000
Working deadline: Hard-51 (s)3,000 or 4,500

Table 6. Reference GAD hyperparameters and per-task budgets. Output allowances are initial per-response limits; response recovery may increase them up to 32,768 tokens. Saved run overrides take precedence.

Each worker receives the original task, its assigned node and acceptance conditions, parent and dependency information, recent local execution records, and relevant shared artifacts. Nodes are decomposed only when local execution evidence reveals prerequisites. Retrieved candidates can be reused only after contract and dependency compatibility checks. A separate verifier evaluates the complete node goal and every acceptance clause; completing child nodes alone does not verify their parent. The templates below reproduce the reference worker instructions, including the verification-request format, with presentation-only formatting changes. Braced input fields are populated by the runtime. The worker prompt’s \{max_children\} and \{max_routes_per_node\} take the configured values in Table 6. Algorithm 1 Workflow of GAD

Require: Instruction II, environment s0s_0, policy π\pi, budget BB Ensure: Final environment state and root completion status

  1. Initialize G=({vroot},∅)\mathcal{G} = (\{v_{\mathrm{root}}\}, \varnothing), R←∅\mathcal{R} \leftarrow\varnothing, and s←s0s \leftarrow s_0

  2. Set root goal to II, acceptance to full satisfaction of II, and status to READY

  3. while true do

  4. Update node states from dependency and route outcomes, following § 3.1

  5. break if root is VERIFIED or budget is exhausted

  6. Compute F\mathcal{F} by Eq. (6); break if F=∅\mathcal{F} = \varnothing

  7. Select v∈Fv \in\mathcal{F}; launch an agent and set σv←ACTIVE\sigma_v \leftarrow\mathrm{ACTIVE}

  8. Construct ct,vc_{t,v} by Eq. (7)

  9. Sample ut,v∼π(⋅∣ct,v)u_{t,v} \sim\pi(\cdot\mid c_{t,v}); register evidence-backed findings in R\mathcal{R}

  10. if ut,vu_{t,v} requests RUN then

  11. Execute its command; update ss and append observations to hvh^v

  12. else if ut,vu_{t,v} requests DECOMPOSE then

  13. Obtain (bv,fv)(b_v, f_v) by checking dvd_v using Eq. (3)

  14. If bv=0b_v = 0, retain fvf_v, set vv READY, and continue

  15. Create or reuse CvC_v and resolve dependency edges DvD_v

  16. Expand G\mathcal{G} by Eq. (4); register ρv,k=Cv\rho_{v,k} = C_v; set vv WAITING

  17. else if ut,vu_{t,v} requests SEARCH then

  18. Retrieve results using its query for the next context; set vv READY

  19. else if ut,vu_{t,v} requests VERIFY then

  20. Compute qvq_v by Eq. (8)

  21. if qv=1q_v = 1, set vv VERIFIED and publish its verified result in R\mathcal{R}

  22. else retain verification feedback and set vv READY

  23. end if

  24. Return vv to READY if it remains ACTIVE

  25. end while

Role and Coordination Rules

You are a disposable LOCAL WORKER in a long-horizon terminal task system. There is NO Planner. You own exactly one obligation node in a lazily growing execution DAG. Do not produce a global plan. Reason only about this node, its parents/dependencies, local evidence, and retrieved reusable artifacts.

The DAG is a hard coordination contract:

  1. Work only on the assigned node.

  2. A node may be solved directly; decomposition is NOT mandatory.

  3. DECOMPOSE only after concrete local execution evidence reveals independent prerequisites/blockers. "The task is broad" is NOT sufficient.

  4. Every DECOMPOSE must cite one or more prior local evidence step IDs; the runtime rejects uncited graph growth.

  1. Decomposition creates ONE alternative AND-route: every child in that route must be VERIFIED before the parent can be retried.

  2. The parent NEVER becomes verified merely because children finish. It must later pass its own acceptance check.

  3. New children must be narrower/more local/more verifiable than the parent. At most {max_children} children per route and {max_routes_per_node} routes per parent.

  4. Prefer SEARCH/reuse over duplicate work.

  5. Never access hidden benchmark solutions, hidden verifier state, credentials, or host data.

Collaboration is artifact-mediated, not conversational. You may publish claims supported by PRIOR local step IDs. You cannot self-declare a claim VERIFIED: ordinary published facts become OBSERVED; hypotheses stay HYPOTHESIS. Only runtime verification creates VERIFIED artifacts.

Execution and Retrieval

Output format:

Choose exactly ONE action and return exactly one JSON object (no markdown):

  1. RUN one coherent shell command:

{
  "action":"RUN",
  "reason":"...",
  "mode":"INSPECT|MUTATE|TEST|SERVICE|OTHER",
  "command":"...",
  "write_targets":["relative/path/or/resource"],
  "publish":[{"kind":"fact|diagnostic|hypothesis|artifact","description":"...",

"evidence_steps":[1],

"tags":["..."]}]

For INSPECT/TEST use write_targets=[] unless the command intentionally mutates persistent state. For MUTATE/SERVICE declare the smallest realistic write/resource targets; use ["*"] only if truly global/unknown.

  1. SEARCH reusable artifacts:

{"action":"SEARCH","reason":"...",
"query":"...","publish":[]}

Evidence-Grounded Decomposition

  1. DECOMPOSE this node into one new AND-route:

{
  "action":"DECOMPOSE",
  "reason":"evidence-grounded reason
this node should grow children",
  "evidence_steps":[12],
  "route_label":"short approach name",
  "children":[
    {
      "local_id":"c1",
      "goal":"one self-contained narrower obligation",
      "depends_on":[],
      "acceptance":[{"description":""}],
      "read_scope":["..."],
      "write_scope":["..."],
      "tags":["..."]
    }
  ],
  "publish":[]
}

Child depends_on may reference local_id values from this same route or already-visible dependency node IDs. Do not reference the parent.

Verification and Control Actions

  1. VERIFY this node. If the current acceptance contract is missing/incomplete, propose up to 4 non-destructive checks:

{
  "action":"VERIFY",
  "reason":"why evidence suggests
the node may be complete",
  "checks":[{"description":"...","command":"..."}],
  "publish":[]
}

Mechanical checks are preferred. If no command can reasonably verify the node, leave commands empty and a strict semantic verifier will inspect concrete evidence.

  1. ABANDON only the CURRENT METHOD when it is unproductive. This does NOT mean the obligation is impossible and does not fail the node:

{"action":"ABANDON","reason":"":[12],"publish":[]}
  1. BLOCK only when concrete evidence shows this obligation cannot currently proceed under its contract/environment (e.g. unavailable required external resource). BLOCK is stronger than ABANDON and causes the containing route to fail so that a parent may try an alternative route:

{"action":"BLOCK","reason":"",
"evidence_steps":[12],
"publish":[]}
  1. YIELD when another READY node should proceed or you have no useful next local action:

{"action":"YIELD","reason":"...","publish":[]}

Never invent command outputs. Do not repeat an unchanged failed command. Keep reason under 120 characters. Use publish=[] unless a claim will help later. Keep each command focused and JSON complete.

Local Input Context

Input Information (user message):

LOCAL NODE CONTEXT:

{serialized_local_node_context}

The serialized context contains the following runtime fields:

  • root_task: the original benchmark instruction.

  • node: identifier, goal, depth, status, attempts, verification failures, acceptance conditions, scopes, tags, and runtime feedback.

  • parents, dependencies, and routes_from_this_node: relevant graph state and verified dependency artifacts.

  • local_evidence and local_artifacts: recent execution records and outputs of the assigned node.

  • retrieved_artifacts and last_search_query: shared results retrieved by the runtime or an explicit search.

References

  1. [1]Akari Asai, Zeqiu Wu, Yizhong Wang, Avi Sil, and Hannaneh Hajishirzi. 2024. Self-rag: Learning to retrieve, generate, and critique through self-reflection. In International conference on learning representations, Vol. 2024, 9112–9141.arxiv.org/abs/2310.11511
  2. [2]Zhaorun Chen, Zhuokai Zhao, Kai Zhang, Bo Liu, Qi Qi, Yifan Wu, Tarun Kalluri, Xuefei Cao, Yuanhao Xiong, Haibo Tong, et al. 2026. Scaling agent learning via experience synthesis. In International Conference on Learning Representations, Vol. 2026. 121394–121420.arxiv.org/abs/2511.03773
  3. [3]Xuan Dang, Qian Qian, Xueheng Luo, Jingru Fan, Zizhao Xie, Ruijie Shi, Weize Chen, Cheng Yang, Xiaoyin Che, Ye Tian, et al. 2026. Multi-agent collaboration via evolving orchestration. Advances in neural information processing systems 38 (2026), 165025–165509.arxiv.org/abs/2505.19591
  4. [4]Xiang Deng, Jeff Da, Edwin Pan, Yannis Yiming He, Charles Ide, Kanak Garg, Niklas Lauffer, Andrew Park, Nitin Pasari, Chetan Rane, et al. 2025. Swe-bench pro: Can ai agents solve long-horizon software engineering tasks? arXiv preprint arXiv:2509.16941 (2025).arxiv.org/abs/2509.16941
  5. [5]Lutfi Eren Erdogan, Hiroki Furuta, Sehoon Kim, Nicholas Lee, Suhong Moon, Gopala Anumanchipalli, Kurt Keutzer, and Amir Gholami. 2025. Plan-and-Act: Improving Planning of Agents for Long-Horizon Tasks. In Forty-second International Conference on Machine Learning. https://openreview.net/forum?id=bvA4EcMmUZarxiv.org/abs/2503.09572
  6. [6]Adam Fourney, Gagan Bansal, Hussein Mozannar, Cheng Tan, Eduardo Salinas, Friederike Niedtner, Grace Proebsting, Griffin Bassman, Jack Gerrits, Jacob Alber, et al. 2024. Magentic-one: A generalist multi-agent system for solving complex tasks. arXiv preprint arXiv:2411.04468 (2024).arxiv.org/abs/2411.04468
  7. [7]Sirui Hong, Mingchen Zhuge, Jialong Chen, Xiawu Zheng, Yuheng Cheng, Jinlin Wang, Ceyao Zhang, Zili Wang, Steven Ka Shing Yau, Zijuan Lin, Liyang Zhou, Chenyu Ran, Lingfeng Xiao, Chenglin Wu, and Jürgen Schmidhuber. 2024. MetaGPT: Meta Programming for A Multi-Agent Collaborative Framework. In The Twelfth International Conference on Learning Representations. https://openreview.net/forum?id=VtmBAGCN7oarxiv.org/abs/2308.00352
  8. [8]Bowen Jin, Hansi Zeng, Zhenrui Yue, Jinsung Yoon, Sercan O Arik, Dong Wang, Hamed Zamani, and Jiawei Han. 2025. Search-R1: Training LLMs to Reason and Leverage Search Engines with Reinforcement Learning. In Second Conference on Language Modeling. https://openreview.net/forum?id=Rwhi91ideu
  9. [9]Han Li, Zhemin Fang, Rili Feng, Yingqi Zhao, Jiaheng Liu, Pengfei Gao, He Ye, Dayi Lin, Qingwei Lin, Saravan Rajmohan, et al. 2026. LoopsBench: From Harness Engineering to Loop Engineering in Coding Agent Evaluation. arXiv preprint arXiv:2608.00267 (2026).arxiv.org/abs/2608.00267
  10. [10]Xiaoli Li, Jiajie Jin, Guanting Dong, Hongjin Qian, Yongkang Wu, Ji-Rong Wen, Yutao Zhu, and Zhicheng Dou. 2026. Webthinker: Empowering large reasoning models with deep research capability. Advances in Neural Information Processing Systems 38 (2026), 120091–120131.
  11. [11]Zongxia Li, Zhongzhi Li, Yucheng Shi, Ruhan Wang, Junyao Yang, Zhichao Liu, Xiangyu Wu, Anhao Li, Yue Yu, Ninghao Liu, et al. 2026. Long-horizon-terminal-bench: Testing the limits of agents on long-horizon terminal tasks with dense reward-based grading. arXiv preprint arXiv:2607.08964 (2026).arxiv.org/abs/2607.08964
  12. [12]Ziyu Ma, Hailang Huang, Shun Zou, Yong Wang, Shidong Yang, Yiming Hu, Fei Wei, and XiangXiang Chu. 2026. Longhorizon-harness: Advancing long-horizon agents for real-world tasks. arXiv preprint arXiv:2608.01964 (2026).arxiv.org/abs/2608.01964
  13. [13]Mike Merrill, Alexander Shaw, Nicholas Carlini, Boxuan Li, Harsh Raj, Ivan Bercovich, Lin Shi, Jeong Shin, Thomas Walshe, E Kelly Buchanan, et al. 2026. Terminal-bench: Benchmarking agents on hard, realistic tasks in command line interfaces. In International Conference on Learning Representations, Vol. 2026. 40903–40986.
  14. [14]Aneesh Pappu, Mirac Suzgun, Yongchan Kwon, Federico Bianchi, Batu El, Mykel J. Kochenderfer, Hancheng Cao, and James Zou. 2026. Self-Organizing Agent Teams Learn to Reason Together. arXiv:2609.22682 [cs.AI] https://arxiv.org/abs/2609.22682
  15. [15]Jianhao Ruan, Zihao Xu, Yiran Peng, Fashen Ren, Zhaoyang Yu, Xinbing Liang, Jinyu Xiang, Yongru Chen, Bang Liu, Chenglin Wu, et al. 2026. Aorchestra: Automating sub-agent creation for agentic orchestration. arXiv preprint arXiv:2602.03786 (2026).arxiv.org/abs/2602.03786
  16. [16]Weiwei Sun, Miao Lu, Zhan Ling, Kang Liu, Xuesong Yao, Yiming Yang, and Jiecao Chen. 2025. Scaling long-horizon llm agent via context-folding. arXiv preprint arXiv:2510.11967 (2025).arxiv.org/abs/2510.11967
  17. [17]Junlin Wang, Jue Wang, Ben Athiwaratkun, Ce Zhang, and James Y Zou. 2025. Mixture-of-agents enhances large language model capabilities. In International Conference on Learning Representations, Vol. 2025. 33944–33963.arxiv.org/abs/2406.04692
  18. [18]Yi Wang, Haopeng Zhang, Chengxiang Huang, Rui Dai, Kaikui Liu, Piotr Kominusz, and Xiangxiang Chu. 2026. LoopArena: Benchmarking Models as Runtime Controllers for Loop Engineering. arXiv preprint arXiv:2608.28281 (2026).arxiv.org/abs/2608.28281
  19. [19]Zihan Wang, Kangrui Wang, Qining Wang, Pingyue Zhang, Linjie Li, Zhengyuan Yang, Xing Jin, Kefan Yu, Minh Nhat Nguyen, Licheng Liu, et al. 2025. Ragen: Understanding self-evolution in llm agents via multi-turn reinforcement learning. arXiv preprint arXiv:2504.20073 (2025).arxiv.org/abs/2504.20073
  20. [20]Zhaoyang Wang, Cawen Xu, Boyi Liu, Yite Wang, Siwei Han, Zhewei Yao, Huaxiu Yao, and Yuxiong He. 2026. Agent world model: Infinity synthetic environments for agentic reinforcement learning. arXiv preprint arXiv:2602.10090 (2026).arxiv.org/abs/2602.10090
  21. [21]Xii Wu, Kuan Li, Yida Zhao, Liwen Zhang, Litu Ou, Huifeng Yin, Zhongwang Zhang, Xinmiao Yu, Dingchu Zhang, Yong Jiang, et al. 2025. Resum: Unlocking long-horizon search intelligence via context summarization. arXiv preprint arXiv:2509.13313 (2025).arxiv.org/abs/2509.13313
  22. [22]Zhiheng Xi, Jixuan Huang, Chenyang Liao, Baodai Huang, Honglin Guo, Jiaqi Liu, Rui Zheng, Junjie Ye, Jiazheng Zhang, Wenxiang Chen, et al. 2025. Agentgym-rl: Training llm agents for long-horizon decision making through multi-turn reinforcement learning. arXiv preprint arXiv:2509.08755 (2025).arxiv.org/abs/2509.08755
  23. [23]Yiheng Xu, Dunjie Lu, Zhennan Shen, Junlin Wang, Zekun Wang, Yuchen Mao, Caiming Xiong, and Tao Yu. 2025. Agenttrek: Agent trajectory synthesis via guiding replay with web tutorials. In International Conference on Learning Representations, Vol. 2025. 79822–79843.
  24. [24]John Yang, Kilian Lieret, Carlos Jimenez, Alexander Wettig, Kabir Khandpur, Yanzhe Zhang, Binyuan Hui, Ofir Press, Ludwig Schmidt, and Diyi Yang. 2026. Swe-smith: Scaling data for software engineering agents. Advances in Neural Information Processing Systems 38 (2026).arxiv.org/abs/2504.21798
  25. [25]Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, and Yuan Cao. 2022. React: Synergizing reasoning and acting in language models. arXiv preprint arXiv:2210.03629 (2022).arxiv.org/abs/2210.03629
  26. [26]Sukwon Yun, Jie Peng, Pingzhi Li, Wendong Fan, Jie Chen, James Zou, Guohao Li, and Tianlong Chen. 2026. Graph-of-Agents: A Graph-based Framework for Multi-Agent LLM Collaboration. In The Fourteenth International Conference on Learning Representations. https://openreview.net/forum?id=34cANdsHKV
  27. [27]Guibin Zhang, Yanwei Yue, Xiangguo Sun, Guancheng Wan, Miao Yu, Junfeng Fang, Kun Wang, Tianlong Chen, and Dawei Cheng. 2025. Ge-Designer: Architecting Multi-agent Communication Topologies via Graph Neural Networks. In Proceedings of the 42nd International Conference on Machine Learning (Proceedings of Machine Learning Research, Vol. 267), Aarti Singh, Maryam Fazel, Daniel Hsu, Simon Lacoste-Julien, Felix Berkenkamp, Tegan Maharaj, Kiri Wagstaff, and Jerry Zhu (Eds.). PMLR, 76678–76692. https://proceedings.mlr.press/v267/zhang25cu.htmlDOI
  28. [28]Jiayi Zhang, Jinyu Xiang, Zhaoyang Yu, Fengwei Teng, Xionghui Chen, Jiaqi Chen, Mingchen Zhuge, Xin Cheng, Sirui Hong, Jinlin Wang, et al. 2025. Aflow: Automating agentic workflow generation. In International Conference on Learning Representations, Vol. 2025. 30440–34077.arxiv.org/abs/2410.10762
  29. [29]Zijian Zhou, Ao Qu, Zhaoxuan Wu, Sunghwan Kim, Alok Prakash, Daniela Rus, Bryan Kian Hsiang Low, and Paul Liang. 2026. Mem1: Learning to synergize memory and reasoning for efficient long-horizon agents. In International Conference on Learning Representations, Vol. 2026. 58413–58438.arxiv.org/abs/2506.15841
  30. [30]Kaijie Zhu, Yuzhou Nie, Yijiang Li, Yiming Huang, Jialian Wu, Jiang Liu, Ximeng Sun, Zhenfei Yin, Lun Wang, Zicheng Liu, et al. 2026. Termigen: High-fidelity environment and robust trajectory synthesis for terminal agents. arXiv preprint arXiv:2602.07274 (2026).arxiv.org/abs/2602.07274
  31. [31]Mingchen Zhuge, Wenyu Wang, Louis Kirsch, Francesco Faccio, Dmitrii Khizbullin, and Jürgen Schmidhuber. 2024. GPTSwarm: Language Agents as Optimizable Graphs. In Forty-first International Conference on Machine Learning. https://openreview.net/forum?id=uTC9AFXThgarxiv.org/abs/2402.16823

Paper details

vlnc:W_n533jun4
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents