LLM-powered autonomous systems have demonstrated promising capabilities in mathematical reasoning, engineering, and cybersecurity. Yet how to organize these systems for effective, reliable, and sustained performance remains an open question. In this paper, we present CAIRN, a fact-intent-driven multi-agent paradigm for goal-directed exploration. CAIRN represents observations and planned investigations as a dynamic directed acyclic graph (DAG). A reasoner interprets facts to propose intents, which workers execute to produce new facts. Each intent references its supporting facts and defines a potential exploration branch. The persistent graph preserves goals, dependencies and findings across workers, supporting knowledge reuse and parallel exploration. The graph also makes execution trajectories traceable and auditable, providing a basis for human verification and intervention. We evaluate CAIRN across cybersecurity and mathematical reasoning tasks, examining task success, time to solution, and token consumption. DAG-based coordination can incur higher token costs with no observable performance gains on tasks that require little effort. However, on high-effort tasks (at least 1M tokens), we observe faster solutions in 76.5% of cases, with speedups of up to 3.08x. Moreover, as task effort increases, these time gains become more pronounced while relative token overhead declines, highlighting the potential of DAG-guided parallel exploration.
Figures & tables
Figure 1: Exploration over a shared fact – intent DAG. The reasoner reads graph state and proposes intent s citing source fact s ( 1 Propose). The dashed dispatcher receives candidate intent s and assigns eligible candidates ( 2 Assign). worker s execute assigned intent s using a graph snapshot and record outcome fact s ( 3 Record). In the illustrated graph, f1 and f2 support i4 . The reasoner drops i5 when new evidence contradicts its underlying premise.
Figure 2: Two approaches to the same credential-recovery task. (a) A sequential action–observation trajectory. (b) Cairn ’s fact – intent DAG. Three investigations start from the origin and examine the portal, API, and session tokens. The API and token findings jointly motivate a subsequent investigation toward the goal .
Figure 3: Cairn execution architecture. The dispatcher starts reasoner and worker sessions with graph snapshots. Sessions submit changes through the graph service; worker s also use task tools. Accepted updates persist for later sessions and notify the dispatcher . Solid arrows show assignments, updates, and task actions; dashed links show graph state and snapshots.
Figure 4: General agent behavior design factors. Cairn focuses on task architecture as a multi-agent coordination paradigm, while other factors are held constant as the basis for comparison in the evaluation. The examples in each area illustrate representative design choices.
Table 5
Figure 5: Time–token trade-offs across the 52 tasks. Arrows run from Direct to Cairn ; labels on the right name the tasks on which Cairn finishes sooner than Direct ; lines connect each label to its Cairn endpoint. Shading shows where Cairn endpoints cluster within each outcome group.
Figure 6: Task-level performance by effort and benchmark. In (a,b), points show tasks in the three baseline-token effort groups of Table 2 ; lines connect arithmetic means, light and dark boxes span the 10th–90th and 25th–75th percentiles, and n gives group size. In (c,d), circles denote FrontierMath and triangles Cybench tasks; shaded contours show task density.
Figure 7: Time advantage versus task effort. The vertical axis shows TD/TC , where TD is the solving time of Direct and TC is Cairn ; values above one favor Cairn . The line shows a pooled log–log linear fit with a pointwise 95% task-bootstrap confidence band. The horizontal line marks equal time ( TD/TC=1 ), and the vertical dotted line marks the fitted crossing at 1.24M tokens.
Figure 8: Active worker s in three Cairn runs on the same FrontierMath problem (fm-02). Each execution slot runs one agent session at a time; reasoner and worker sessions share the available slots. Colored bands count simultaneously active worker s; blank intervals may include reasoner activity or tool execution.
Figure 9: Execution timeline for fm-02. The 26.47-minute timestamp measures submission from the first model request; 26.51-minute solving time includes initialization and verification. Squares mark intent starts, circles mark fact s, and charcoal spans mark reasoner activity. Pale streams lack recorded completion before submission.
Figure 10: Complete coordination traces for two FrontierMath Cairn runs: fm-05 (top) and fm-01 (bottom). Left: fact – intent DAGs. Right: execution flows with elapsed time in minutes. Red highlights answer-related paths, and stars mark accepted submissions.
Appendix figures & tables2 assets
Supplementary material from the paper’s appendix.
Appendix
Field
Role
Supplied content
graph_yaml
Reasoner, worker
Instructions to read a YAML snapshot file stored in the project container.
fact_ids
Reasoner
Identifiers of available fact s, excluding the terminal goal .
open_intents
Reasoner
Open intent identifiers, source identifiers, descriptions, assigned workers, and priorities.
max_intents
Reasoner
Per-invocation creation limit, or the literal value unlimited .
worker_capacity
Reasoner
Execution limits and slot availability at dispatch, including the reasoner’s slot.
intent_progress
Reasoner
Timestamped progress summary supplied at dispatch.
Appendix
Table 3: Fields used to instantiate the role prompts.
Tool
Role
Principal arguments
Result or effect
submit_fact
W
Description
Adds a fact linked to the assigned intent ; returns its identifier.
finish_intent
W
fact identifier
Concludes the assigned intent with a fact submitted by this execution.
create_intent
R
Source fact s, description, priority
Adds an intent supported by existing fact s; returns its identifier.
set_intent_priority
R
intent identifier, priority
Updates the scheduling priority of an open intent .
drop_intent
R
intent identifier, reason
Retires an open intent and revokes its worker’s access.
finish_reason
R
Description, outcome
Ends the review as planned or incomplete; acknowledges the reviewed revision.
Appendix
Table 4: Agent-facing MCP tools. R denotes the reasoner; W denotes workers. Every state-changing call also requires a submission_key . Arguments are summarized; pagination options are omitted.
Large language models (LLMs) enable autonomous agents for reasoning, planning, and tool use. Recent systems increasingly organize these agents as graphs of specialized, interconnected nodes. Although graph-based orchestration supports flexible decomposition and coordination, it creates a key challenge: attention allocation. As workflows grow, existing approaches often execute graph components uniformly, wasting resources on irrelevant or low-impact tasks. We introduce Attention Orchestration, a paradigm that extends Transformer-style attention from token representations to workflow-level agent coordination. Our framework, Adaptive Goal-aware Attention Orchestration (AGAO), dynamically estimates agent importance based on user objectives, graph dependencies, and computational constraints. AGAO combines three components: (1) goal-aware attention, measuring semantic relevance between user goals and agent capabilities; (2) topology-aware attention, modeling structural dependencies in agent graphs; and (3) resource-aware attention, allocating budgets and execution priorities across heterogeneous agents. Together, these mechanisms transform static agent graphs into adaptive systems that focus computation on goal-critical reasoning paths. Experiments across diverse multi-agent workloads show that AGAO improves task effectiveness while reducing unnecessary computation, latency, and token consumption compared with existing graph-based execution strategies. Our work establishes Attention Engineering as a direction for scalable, intelligent multi-agent systems. Code: https://github.com/MingzhouFan97/AGAO.
Deep research tasks require agents to navigate large knowledge spaces, synthesize evidence across many sources, and adapt their plans as findings emerge. Directed acyclic graph (DAG)-based multi-agent systems suit this setting because they support parallel execution and isolate each sub-task within a focused dependency context. Yet existing DAG-based agents instantiate a task-level plan before execution and repair the graph only after failures or missing evidence are observed. This Plan-then-Patch strategy is brittle for deep research: the system commits most strongly when its evidence is weakest, and later revisions waste computation on branches that should not have been planned. We propose DAGent, a DAG-based multi-agent framework with Evaluate-then-Grow incremental planning: an Orchestrator grows the task graph one batch at a time, conditioning each expansion on confidence and uncertainty signals from completed nodes. A hierarchical context layer propagates compact QueryDocs by default while preserving full execution traces for on-demand recall. The recorded DAG topology admits structural RL signals that outcome-only recipes cannot define; DAGRPO, a GRPO adaptation, injects topology-conditioned credit on Executor rollouts and a structural compliance regularization on Orchestrator plans. Across BrowseComp-Plus, GAIA, and xbench-DeepSearch, DAGent surpasses the strongest open-source baseline by 5.3 / 5.8 / 2.0 points at the Qwen3-235B-A22B scale, and the lead replicates across four open-source backbones and extends to GPT-5 at 327K context. At the Qwen3-8B scale, DAGRPO improves over a same-budget outcome-only GRPO baseline by 3.0 average Pass@1 points. A same-architecture comparison shows that evidence-conditioned planning reaches higher accuracy at lower per-task token, tool-call, and step footprints than its Plan-then-Patch counterpart. Code: https://github.com/hanwenliu6825/DAGent
Hanwen Liu, Yuanfu Sun, Qiaoyu Tan
New York University · New York University Shanghai
Recent multi-agent LLM systems increasingly rely on graph-structured communication to coordinate specialized agents. We revisit multi-agent orchestration from a graph-engineering perspective: rather than optimizing a static topology, we synthesize a task-conditioned temporal workflow graph that jointly specifies agent connectivity and edge-level communication semantics. We introduce ReActNet, a training-free framework that compiles a query and a set of role-specialized agents into a sequence of directed communication graphs. Each graph snapshot corresponds to one reasoning stage, and each edge carries a natural-language instruction specifying the message that a source agent should provide to a target agent. The compiled temporal graph is then executed through structured message passing: agents update their reasoning states by integrating their previous states with messages from controller-assigned neighbors, and a final aggregator synthesizes the resulting states into the answer. This design separates graph compilation from graph execution, making multi-agent coordination explicit, inspectable, and task-conditioned without requiring reinforcement learning or gradient-based topology optimization. Across knowledge reasoning, mathematical problem solving, code generation, and GAIA-style assistant tasks, ReActNet consistently improves over fixed-topology and learned-topology baselines while maintaining competitive inference cost. These results suggest that effective multi-agent orchestration depends not only on which agents communicate, but also on engineering executable workflow graphs that encode when, why, and how information should flow during reasoning.
Katherine Tieu, Dongqi Fu, Yinglong Xia +3
Meta · University of Illinois Urbana-Champaign · Work done at Meta