Atomic Task Graph: A Unified Framework for Agentic Planning and Execution

Abstract: LLM-based agents have shown strong potential for solving complex multi-step tasks, yet existing performance improvements often rely on either scaling to larger backbone models or task-specific fine-tuning. The former incurs substantial computational costs, while the latter typically generalizes poorly across different tasks. Although prompt-based control is training-free and broadly applicable, existing methods still leave input-output dependencies between subtasks implicit in textual trajectories, making verified intermediate results difficult to reuse. To address these limitations, we propose Atomic Task Graph (ATG), a unified control framework for planning and execution. Specifically, ATG maintains an explicit graph to expose dependencies and support reuse. During planning, it recursively decomposes a high-level task into subtasks, forming a sequence of directed acyclic graphs (DAGs) whose evolution can be traced. During execution, the dependencies exposed by ATG allow independent branches to be executed in parallel, thereby improving execution efficiency. When failures are detected, ATG leverages the graph evolution history to localize the error source and repair only the affected region, preserving validated regions unchanged. Experiments show that ATG consistently outperforms strong baselines in success rate and execution efficiency across three interactive benchmarks using only 7B-8B backbones.

• The paper presents a novel graph-based framework that decomposes complex tasks into atomic tool-use nodes with explicit input-output dependencies.
• It leverages recursive interface-preserving decomposition and dependency-aware parallel execution to reduce error propagation and enhance efficiency.
• Empirical results show significant improvements in task success and execution efficiency, outperforming traditional linear and tree-based planning approaches.

Atomic Task Graph: A Unified Graph-Based Framework for Agentic LLM Planning and Execution

Motivation and Limitations of Existing Paradigms

Autonomous LLM agents capable of solving complex multi-step tasks have proliferated in recent years, yet control frameworks predominantly rely on either scaling up backbone model capacity or supervision-intensive, task-specific fine-tuning. These strategies are computationally prohibitive or fail to generalize across diverse environments, respectively. Prompt-based methods, though flexible and training-free, embed input-output dependencies implicitly in long textual trajectories, compounding error propagation, error localization difficulty, and context-related hallucinations. As illustrated by a direct comparison, the linear decision paradigm lacks explicit dependency tracking, facilitating the coupling and proliferation of errors along the action trajectory.

Figure 1: Comparison between the linear decision paradigm and Atomic Task Graph, highlighting the limitations of linear approaches for dependency tracking and local repair.

The Atomic Task Graph Framework

The paper introduces the Atomic Task Graph (ATG), an inference-time, unified planning and execution control framework that organizes agentic decision processes as explicit, interface-preserving DAGs of atomic tool-use nodes. Each node in the graph corresponds to a tool call, with edges encoding concrete input-output dependencies, generalizing both linear and tree-based plans.

Core design innovations of ATG include:

• Recursive interface-preserving graph compilation: Planning is recast as a recursive decomposition of coarse user objectives, refining non-atomic nodes into subgraphs of lower granularity while maintaining strict input-output interface compatibility. This ensures compositionality and stable inter-node interaction, supporting stepwise error tracing and local verification.
• Dependency-aware execution: The explicit DAG structure enables parallel execution of independent computation branches, non-sequential action scheduling, and precise node-/edge-level state tracking. This markedly contrasts with previous approaches that accumulate context in linear histories.
• Minimal necessary subgraph repair: ATG enables strict failure localization by leveraging the recursive graph evolution history. Only the smallest graph region underpinning a detected failure is targeted for repair, freezing validated components and avoiding expensive re-execution of unrelated subgraphs.

  Figure 2: Visualization of the overall ATG framework, showing compilation, execution, and repair stages.

Graph Compilation: Recursive Decomposition and Localized Context

Complex agentic tasks are decomposed via recursive graph compilation into executable atomic units. At each stage, the LLM accesses only node-local context, reducing long-range context drift and potential for hallucinated actions. The process enforces semantic interface preservation: a child subgraph must consume and output data in compliance with its parent’s interface specification, enabling compositional updates and ensuring that replacements at any depth do not disrupt overall plan validity.

The refinement evolves from high-level abstractions to finely-grounded tool invocations, generating a graph sequence that allows for interpretability (e.g., tracing failed nodes back through refinement versions) and underpins targeted repair.

Figure 3: ATG recursively decomposes a coarse task into atomic tool-use steps, explicitly capturing and preserving input-output interfaces at each refinement.

Dependency-Aware Parallel Execution and Pre-execution Simulation

Unlike agentic methods governed by serial context evolution, the ATG execution phase leverages the explicit DAG to orchestrate parallel node execution whenever input dependencies are satisfied, enhancing efficiency and reducing cumulative step counts.

A lightweight pre-execution thought experiment acts as a validation filter, simulating execution to catch invalid node assignments, missing dependencies, tool selection errors, and interface misalignments prior to any environment interaction. This approach curtails wasted computation and early-stage irreversible errors.

Minimal Subgraph Repair and Failure Localization

When execution or pre-execution validation exposes a failure, ATG identifies the failed atomic node(s) and traces them to their lowest common ancestor in the recursive refinement history. The repair process then targets the minimal affected subgraph encompassing these nodes and their relevant context, leaving unrelated, validated sections of the graph unperturbed. This localized repair strategy increases robustness, reduces recomputation, and stabilizes long-horizon planning.

Empirical Results and Ablation Analysis

ATG demonstrates consistent and significant gains in both task success rates and execution efficiency across diverse benchmarks (ALFWorld, WebShop, ScienceWorld) and backbones (Mistral-7B, Gemma-7B, Llama-3-8B), surpassing state-of-the-art implicit, explicit, and multi-agent control baselines.

Strong numerical outcomes include:

• On Mistral-7B, ATG improves over ReAct by 49.16 (ALFWorld) and 48.12 (WebShop) points.
• Against the strongest explicit-structure baseline (PoG), ATG achieves +32.01 (ALFWorld) and +38.57 (WebShop) point gains.
• Notably, ATG with Llama-3-8B outperforms GPT-4 ReAct on ALFWorld and WebShop, without requiring backbone scaling.

Component ablations indicate that both the pre-execution thought experiment and localized subgraph repair are essential for maximizing reliability and efficiency. Exclusion of either component leads to marked performance regression, with the absence of subgraph repair generating particularly pronounced degradation on long-horizon environments.

Figure 4: Ablation results reveal the necessity of both thought experiment and localized subgraph repair for optimal agentic performance.

Figure 5: Pre-execution thought experiment catches risky plans early, with high precision—saving considerable environment interactions and preventing cascading failures.

The analysis shows further that ATG reduces the average execution step count by up to 41.6% compared with ReAct and achieves a hallucinatory action reduction of up to 71.7%. This underscores the value of explicit, context-localized dependency management and validation as opposed to linear, text-accumulating agentic paradigms.

Theoretical and Practical Implications

ATG fundamentally separates agentic planning from LLM backbone scaling, demonstrating that structured, graph-based control mechanisms can substantially close the performance gap to more powerful proprietary models. The semantic traceability, compositional refinement, and parallel execution provide a scalable path towards reliable, efficient, and transparent long-horizon agentic systems. Practically, ATG’s training-free, inference-only design is compatible with a wide range of LLMs and domains. The theoretical underpinning—formulating agent task execution as an interface-preserving graph search—sets a new organizing principle for generalist agents.

The research points to further directions at the intersection of program synthesis, tool-augmented reasoning, and robust multi-modal planning. Integrating ATG-like graph substrates with learning-based or gradient-guided planning modules could enhance adaptivity. Application to embodied, multimodal, or real-world settings will require further validation, especially in noisy, open-ended environments. Addressing the reliance on backbone decomposition accuracy and scaling interface protocols for dynamic, asynchronous tasks are future challenges.

Conclusion

Atomic Task Graph (ATG) presents a unified, explicit graph-based paradigm for LLM agentic planning and execution that advances the state of the art in long-horizon, multi-step tasks. The explicit DAG substrate, recursive interface-preserving refinement, dependency-aware execution, and localized repair mechanisms lead to significant improvements in task success, efficiency, and action reliability across diverse domains and backbones. This work motivates a shift from linear, text-centric agent paradigms to explicit, compositional graph-based approaches for future generalist AI systems (2607.01942).