DAG-Based Task Planner Overview

• The DAG-based task planner is a framework that models complex tasks as directed acyclic graphs, enabling systematic decomposition and parallel scheduling.
• It employs schema-aware validation to ensure structural and semantic correctness, facilitating explainable execution traces and reliable task orchestration.
• The system integrates rapid plan generation, caching, and DataOps feedback for error diagnosis and auto-repair, resulting in improved accuracy and reduced latency.

A directed acyclic graph (DAG)-based task planner is a computational or agentic system that models complex, multi-stage reasoning, scheduling, or resource orchestration as the progressive construction, validation, and execution of a DAG. In this architecture, vertices represent atomic tasks, sub-queries, or sub-goals, while edges encode explicit precedence, data, and execution dependencies. The DAG-based model guarantees acyclicity, enabling systematic decomposition of task objectives, scalable parallel scheduling, explainable execution traces, and composable validation logic. These properties are leveraged across multi-modal retrieval, hard real-time scheduling, automated planning, and reinforcement-learning-based orchestration frameworks (B et al., 15 Mar 2026).

1. Formal DAG Plan Definition and Architecture

A DAG-based planner encodes a workflow as a finite directed acyclic graph $\mathcal{P} = (V, E)$, where:

• $V = \{v_1, ..., v_n\}$: Nodes, each representing an atomic sub-task or query, annotated with
  • sub-task description,
  • tool type (e.g., $\texttt{sql}$ or $\texttt{vector}$),
  • output label (e.g., $\$var_i$$),</li> <li>exposure status (whether to expose intermediate results).</li> </ul></li> <li>$$E \subseteq V \times V$: Directed edges encoding dependency;$(v_i \to v_j)$means$v_j$requires completion and outputs of$v_i$(can refer to output fields via$\$var_i.\text{column_name}$).</li> </ul> <p>By maintaining acyclicity,$V = \{v_1, ..., v_n\}$0 can be topologically sorted, enabling algebraic plan validation: plan generation, acyclic check, and variable-scope verification are all $V = \{v_1, ..., v_n\}$1. The system supports maximal concurrency, with the wall-clock makespan governed by the DAG’s critical path length in the infinite-worker model.

    2. Query Decomposition and Plan Generation

    The planner decomposes user input, such as a natural language query $V = \{v_1, ..., v_n\}$2, into a structured DAG, using schema-informed prompting and LLMs. The decomposition process includes:

    • Extraction of atomic sub-tasks (‘hops’) based on schema, data type, and dependency patterns,
    • Assignment of each task to the correct tool (e.g., identification of SQL sub-queries for named-entity or filter patterns, vector-search for semantic link-resolution),
    • Generation of parallelizable sub-queries by identifying independent sub-tasks.

    Pseudocode for plan generation: $\texttt{sql}$4 Heuristics in prompt design maximize parallel hops when cross-node references are absent.

    3. Schema-Aware Validation: Structural and Semantic

    The post-generation plan is subjected to a validator $V = \{v_1, ..., v_n\}$3, ensuring executable and semantically-sound task plans:

    • Structural validation: Every node must have all required fields, well-formed labels, proper tool annotation, and valid references. DAG must remain acyclic, verifiable in $V = \{v_1, ..., v_n\}$4.
    • Semantic validation: Type checking ensures that joins and data passing across nodes use schema-sanctioned keys. Intent-drift is detected via audit prompts to lightweight open-source LLMs. The validator enforces

    $V = \{v_1, ..., v_n\}$5

    so every data dependency is well-defined.

    4. Execution Engine: Parallel Orchestration and Evidence

    Upon validation, the DAG executor launches sub-tasks in topological order, exploiting parallelism among independent nodes. Key features:

    • Parallel invocation of NL2SQL or NL2Vector agents with minimal data passing (pointer-only ‘slimming’),
    • Thread-pool concurrency, with latency determined by the DAG’s critical path,
    • Comprehensive evidence logging: complete provenance trails recording input keys, query text, intermediate outputs, and timestamps for regulatory and user trust.

    Simplified pseudocode: $\texttt{sql}$5 All intermediate and final outputs follow the explicit path of dependencies declared in the DAG.

    5. Caching, Reuse, and Paraphrase-Awareness

    To achieve high throughput and rapid response, the DAG-based planner integrates a multi-tiered caching and plan-reuse system mapping $V = \{v_1, ..., v_n\}$6 to $V = \{v_1, ..., v_n\}$7:

    • Exact caching: Reuse when the normalized query and schema context match exactly, with $V = \{v_1, ..., v_n\}$8 lookup.
    • Template caching: Embedding-similarity combined with slot-based pattern extraction, enabling slot-filling for paraphrased queries.
    • Semantic caching: Retrieve top-$V = \{v_1, ..., v_n\}$9 semantically similar queries, and confirm plan reusability through structural validation; incurs only an extra LLM call on each template hit.
    • Employs LRU cache eviction to maintain bounded memory.

    6. DataOps Feedback Loop: Error Diagnosis and Auto-Repair

    When errors or schema changes arise, a DataOps subsystem is invoked with $\texttt{sql}$0, where $\texttt{sql}$1 is the plan history and $\texttt{sql}$2 is failure metadata. Roles include:

    • Diagnoser: Identifies root causes (tool mismatch, variable-scoping).
    • Fixer: Performs local modifications (filter, field name edits).
    • Recommender: Suggests manual intervention (e.g., external server issues).
    • Replanner: Triggers a full or partial DAG regeneration for deep structure changes.

    Feedback latency is $\texttt{sql}$3 for minor repairs, with fallbacks to regeneration for non-local failures.

    7. Empirical Results and System Impact

    Benchmarked on HybridQA (3,466 questions), the DAG-based planner yields substantial gains over naive retrieval-augmented generation (RAG) and sequential ReAct protocols:

    Metric	A.DOT	Baseline RAG	Absolute Gain
    Correctness	71.0%	56.2%	+14.8%
    Completeness	73.0%	62.3%	+10.7%

    Latency is decreased by up to 30%, exploiting full parallel plan evaluation. The system produces an auditable evidence trail, enabling explicit content verification and lineage tracing. Example: for a multi-hop invoice query, all sub-query results (row IDs, aggregate values, retrieved documents) are versioned and time-stamped, satisfying compliance and trust requirements.

    8. Synthesis and Applicability

    The DAG-based planner paradigm, as instantiated by A.DOT, demonstrates a unified mechanism for:

    • Explicit multi-hop, multi-modal question decomposition,
    • Schema-informed structural and semantic plan validation,
    • Maximal parallelization through isolated sub-query orchestration,
    • Rapid, cache-enabled plan regeneration and reuse,
    • Robust error containment through DataOps-mediated feedback and auto-repair,
    • Auditable, enterprise-grade evidence trails.

    This framework is directly applicable to hybrid data lake QA, but the methodology generalizes to any enterprise or agentic context requiring compositional orchestration over networks of interdependent, concurrent tasks (B et al., 15 Mar 2026).