Agent-Based Query Planner Overview

• Agent-Based Query Planner is a system that decomposes query planning into modular stages managed by specialized agents such as LLMs, neural networks, and classical optimizers.
• It leverages explicit agent-environment interactions using frameworks like POMDPs and DAG-based planning to ensure transparent structure and efficient execution.
• Utilized in systems like QueryGym and AGENTIQL, it integrates reinforcement learning and modular coordination to optimize accuracy, latency, and resource utilization.

An agent-based query planner is a system that decomposes the problem of query planning, typically for databases or information retrieval, into explicit, modular stages orchestrated by one or more agents—usually implemented by LLMs, domain-specific neural networks, classical optimizers, or hybrids—each responsible for a specific planning, reasoning, or acting subtask. This paradigm has seen rapid evolution, from early multi-agent systems employing genetic algorithms for query optimization, to modern frameworks that provide explicit stepwise planning, engine-agnostic relational algebra workflows, and reinforcement-learning driven orchestration in multi-agent retrieval or function-invoking environments. Recent work unifies these concepts through precise POMDP formalizations, DAG-based planning, transparent observation/action interfaces, and modular agent specialization, exemplified by environments such as QueryGym and systems like AGENTIQL, OraPlan-SQL, and TURA (Ananthakrishanan et al., 25 Sep 2025, Heidari et al., 12 Oct 2025, Liu et al., 27 Oct 2025, Zhao et al., 6 Aug 2025).

1. Foundational Formalisms and Architectures

At the core of modern agent-based query planners are precisely specified agent-environment interaction protocols, typically formalized as (partially) observable Markov decision processes (POMDPs), multi-agent MDPs, or DAG construction problems. For example, QueryGym models Natural Language to Query (NL2Query) as a POMDP

$\mathcal{M} = (S, A, \Omega, T, O, R)$

where $S$ encodes the entire environment state (database, query, intermediates), $A$ is the agent’s action set (exploration and relational algebra primitives), $\Omega$ is the observation space, $T$ is the deterministic transition function, $O$ the observation function after every agent action, and $R$ provides a reward signal aligned with plan correctness and efficiency (Ananthakrishanan et al., 25 Sep 2025).

The agent’s action space is typically decomposed into:

• Exploration Primitives: Table/sample preview, schema inspection, value distribution (e.g., preview_table, get_unique_values).
• Relational Algebra Primitives: Explicit operations such as projection ($\pi$), selection ($\sigma$), join ($\bowtie$), aggregation ($\gamma$), union ($\cup$), intersection ($\cap$), and syntactic sugar for order/limit.

Other frameworks employ multi-agent separation: a planner agent for global plan synthesis, and execution agents or SQL agents for code or function emission. For instance, AGENTIQL separates reasoning (table/task selection), question decomposition, coding (sub-query generation), and plan merging into specialized agents with explicit message passing and parallel execution (Heidari et al., 12 Oct 2025).

2. Agent Planning Workflows and Execution Models

An agent-based query planner proceeds through explicit steps:

1. Perception: Observations are received from the environment, including question context, schema details, or feedback on past actions. Observations are routinely structured to allow the agent to reason over only the permitted subspace of environment state, e.g., previews, error logs, or schema attributes (Ananthakrishanan et al., 25 Sep 2025).
2. Planning: The planner agent synthesizes a stepwise plan—ranging from structured sequences of relational algebra operations (Ananthakrishanan et al., 25 Sep 2025) to DAGs over function/tool invocations (Wei et al., 13 Nov 2025, Zhao et al., 6 Aug 2025).
3. Action Selection/Dispatch: Actions are chosen either sequentially (as in RL/POMDP environments) or as a global plan (in DAG planners), communicated to executor agents or submitted to a planning loop (Ananthakrishanan et al., 25 Sep 2025, Heidari et al., 12 Oct 2025, Zhao et al., 6 Aug 2025, Wei et al., 13 Nov 2025). Modular agents may operate concurrently, enabling high parallelism and scalability.
4. Observation, Feedback, and Adaptation: The planner receives structured feedback (success/error, intermediate results) enabling error remediation and iterative refinement. In QueryGym, error traces and partial results are explicitly surfaced in the observation space to support transparency and error recovery (Ananthakrishanan et al., 25 Sep 2025). In systems like OraPlan-SQL, feedback-driven meta-prompting distills new planning guidelines into the planner over multiple refinement cycles (Liu et al., 27 Oct 2025).
5. Termination and Evaluation: The process concludes upon achieving a goal state (e.g., materializing the correct answer table) or exhausting the allowable plan length or resources. Evaluation metrics include execution correctness, step count, error frequency, and cumulative execution cost (Ananthakrishanan et al., 25 Sep 2025).

3. Communication, Modularity, and Multi-Agent Coordination

Recent architectures emphasize explicit modularity and inter-agent communication. An agent-based query planner can be organized in several communication topologies:

• Centralized or Semi-Centralized Planning: A single planner agent orchestrates multiple specialized executor/worker agents, with all communications passing through a central hub. Anemoi extends this by employing a semi-centralized pub/sub server that supports agent-to-agent (A2A) communication, enabling distributed bottleneck detection and plan refinement, as well as reduction in token redundancy (Ren et al., 23 Aug 2025).
• Explicit Plan Representation: Plans are typically encoded as explicit, auditable artifacts—sequences of primitives in QueryGym (Ananthakrishanan et al., 25 Sep 2025), stepwise natural language plans in OraPlan-SQL (Liu et al., 27 Oct 2025), or DAG structures of tool calls in planner-centric frameworks (Wei et al., 13 Nov 2025, Zhao et al., 6 Aug 2025). This explicitness facilitates transparency, error tracing, and auditability.
• Parallel and Hierarchical Execution: Systems like AGENTIQL allow for concurrent execution of decomposed sub-queries, with downstream merge/refinement agents integrating the results (Heidari et al., 12 Oct 2025). TURA employs a DAG planner and a parallel orchestrator to maximize throughput and minimize latency, confirmed by empirical speedups (Zhao et al., 6 Aug 2025).

4. Optimization Strategies and Learning Paradigms

Agent-based query planners leverage a variety of optimization and learning frameworks:

• Cost Models and Personalization: Multi-agent systems such as that in (Feizi-Derakhshi et al., 2010) employ cost models augmented with user-centric relevance functions and GA-driven query evolution, enabling personalized, adaptive optimization. Classical metrics (I/O cost, CPU cost) and user model similarity are combined within hybrid scoring frameworks.
• Reinforcement Learning: Reinforcement learning is a central component in adaptive planning, used to optimize expected answer quality minus cost in MAO-ARAG (PPO with actor-critic updates over workflow compositions) (Chen et al., 1 Aug 2025), or to optimize subtask/operator selection for accurate and efficient reasoning in PRIMA (Lyu et al., 2022).
• Policy Distillation and Modular Training: TURA demonstrates the efficacy of distilling large models into resource-efficient executors via a train-with-thought/infer-without-thought paradigm, crucial for real-time, low-latency settings (Zhao et al., 6 Aug 2025). Octo-planner exploits fine-tuning and multi-LoRA merging to support on-device multi-domain planning, optimizing for memory/energy efficiency (Chen et al., 26 Jun 2024).
• Automated Prompt Refinement and Plan Diversification: OraPlan-SQL’s meta-prompting refines the planner via looped feedback from failed cases, incorporating distilled guidelines into the planner’s system prompt. Plan diversification with stochastic sampling and majority voting enhances robustness under challenging queries or entity mismatches (Liu et al., 27 Oct 2025).

5. Evaluation, Metrics, and Interpretability

The effectiveness of agent-based query planners is evaluated with diverse metrics and empirical protocols:

• Correctness and Validity: Metrics include execution accuracy (fraction of plans producing the gold result), SQL validity (fraction of plans with syntactically valid code), and end-to-end answer quality (e.g., F1 in QA settings). OraPlan-SQL reports >99% SQL validity with 55–57% execution accuracy on challenging bilingual benchmarks, surpassing previous bests by significant margins (Liu et al., 27 Oct 2025).
• Efficiency: Latency, step count, energy consumption, and resource utilization are measured, especially in edge-oriented or parallel planning settings. Octo-planner reports a median planning latency of ≈200 ms and ~0.5 J per query on device, with quantifiable energy savings relative to in-context baselines (Chen et al., 26 Jun 2024). TURA demonstrates a 44.2% latency reduction via DAG-based plan scheduling (Zhao et al., 6 Aug 2025).
• Error Analysis and Diagnostics: Transparent plan representations and explicit observation logs in environments like QueryGym allow for precise error localization and human auditing of agent reasoning (Ananthakrishanan et al., 25 Sep 2025, Heidari et al., 12 Oct 2025).
• Ablation Studies: Systems routinely report the impact of architectural variants (plan merging, routing strategies, prompt refinement, plan diversification) via ablations. For example, AGENTIQL shows planner–executor merging improves execution accuracy by 3–5% over naive heuristics, at the cost of increased latency (Heidari et al., 12 Oct 2025). OraPlan-SQL demonstrates up to 27.89% accuracy improvement from meta-guided prompt refinement (Liu et al., 27 Oct 2025).

6. Extensions and Future Challenges

Scalability, heterogeneity, and dynamic adaptation represent prominent frontiers for agent-based query planners:

• Heterogeneous Multi-Agent Workflows: Next-generation frameworks require the orchestration of agents across diverse models (LLMs, small LLMs), engines (databases, inference servers, streaming), and workflow structures (DAGs, chains, feedback loops), subject to latency/cost/accuracy constraints (Kaoudi et al., 10 Dec 2025). Dynamic optimization employing Pareto frontier pruning, layered caches, and adaptive model selection is essential.
• Real-Time Adaptive Planning: Workflows must accommodate streaming feedback (e.g., actual cardinalities, runtime errors), supporting continuous replanning and plan refinement as in Anemoi (Ren et al., 23 Aug 2025).
• Cross-Engine and Cross-Dialect Generalization: QueryGym’s abstraction to relational algebra and engine-agnostic primitives allows trained agents and planners to generalize across SQL dialects and even non-SQL execution environments (e.g., Spark DataFrames) (Ananthakrishanan et al., 25 Sep 2025).
• Interpretability, Transparency, Auditability: Explicit plan representation, surfacing of intermediate steps, and structured observation/action logging are necessary for practitioner and human-in-the-loop diagnostics, regulatory compliance, and robust failure recovery (Ananthakrishanan et al., 25 Sep 2025, Heidari et al., 12 Oct 2025).
• Automated Agent and Model Selection: Automatic binding of sub-queries to appropriate agent/model/engine pairs, as well as redundancy and cache optimization in large multi-agent graphs, is an open systems and optimization challenge (Kaoudi et al., 10 Dec 2025).

7. Empirical Results and Impact

Agent-based query planners have demonstrated empirically superior results across a variety of domains:

System/Env	Key Metric	Value / improvement	Reference
QueryGym	Planning accuracy, error count, step cost	Explicit stepwise logs, shaped reward for near-correct plans	(Ananthakrishanan et al., 25 Sep 2025)
OraPlan-SQL	Execution Accuracy (EX), SQL Validity (VA)	55–57% EX, >99% VA; +6.3–12.6pp over previous SOTA	(Liu et al., 27 Oct 2025)
AGENTIQL	EX on Spider	86.07% (w/ modular, 14B), vs 89.65% GPT-4 SOTA	(Heidari et al., 12 Oct 2025)
TURA	Session Success Rate	55.1%→64.0% (+8.9%); Latency −44% via DAG	(Zhao et al., 6 Aug 2025)
Octo-planner	On-device plan-accuracy	97–99% with full FT, 72–85% LoRA	(Chen et al., 26 Jun 2024)
Anemoi	Multi-step answer acc	52.73%, +9.09pp vs. baseline; token cost −31%	(Ren et al., 23 Aug 2025)

These improvements have translated to both research and industrial systems, spanning NL2SQL, tool-augmented reasoning, adaptive retrieval, and multi-agent data pipeline composition. The modularity, flexibility, and interpretability of agent-based query planners position them as the foundation for scalable, adaptive, and transparent reasoning over heterogeneous data and computation substrates.