Self-Manager: Parallel Agent Loop for Long-form Deep Research

TL;DR

The paper addresses the bottlenecks of long-horizon deep research caused by linear context growth and blocking in single-agent loops. It introduces Self-Manager, a parallel agent loop that runs asynchronous subthreads with isolated contexts and uses a Thread Control Block for autonomous management. Through experiments on DeepResearch Bench, Self-Manager outperforms single-agent baselines and narrows the gap to proprietary deep-research systems, with ablation and contextual analyses validating its design. The work demonstrates improvements in contextual capacity, efficiency, and generalization, while acknowledging higher runtime overhead due to parallelism.

Abstract

Long-form deep research requires multi-faceted investigations over extended horizons to get a comprehensive report. When handling such complex tasks, existing agents manage context at the subtask level to overcome linear context accumulation and information loss. However, they still adhere to a single context window and sequential execution paradigm, which results in mutual interference and blocking behavior, restricting scalability and adaptability. To address this issue, this paper introduces Self-Manager, a parallel agent loop that enables asynchronous and concurrent execution. The main thread can create multiple subthreads, each with its own isolated context, and manage them iteratively through Thread Control Blocks, allowing for more focused and flexible parallel agent execution. To assess its effectiveness, we benchmark Self-Manager on DeepResearch Bench, where it consistently outperforms existing single-agent loop baselines across all metrics. Furthermore, we conduct extensive analytical experiments to demonstrate the necessity of Self-Manager's design choices, as well as its advantages in contextual capacity, efficiency, and generalization.

Figures (9)

• Figure 1: Overview of our proposed Self-Manager. Compared to classical agent loops, Self-Manager spawns subthreads asynchronously and concurrently, with contexts isolated between threads. Upon completion, each subthread returns its result to the main thread's most recent observation. During execution, the main thread can operate on subthreads and monitor their latest states via the TCB list, thereby enabling autonomous management.
• Figure 2: An illustration of how Self-Manager manages subthreads via TCBs. In each iteration, the environment response in the Observe phase includes both the feedback from the tool call and the TCB list.
• Figure 3: Ablation results on the asynchronous and concurrent capabilities of Self-Manager, showing performance degradation.
• Figure 4: A Case in Asynchronous Parallelism of Self-Manager. It shows that the main thread determines that a running subthread is no longer necessary for the overall task and then terminates it. This self-management mechanism enables early stopping, making execution more adaptive and efficient.
• Figure 5: Ablation study on the design of the Thread Control Block (TCB).