Graph Neural Network Based Action Ranking for Planning
Authors: Rajesh Devaraddi Mangannavar
Stefan Lee
Alan Fern
Prasad Tadepalli
Venue: NeurIPS 2025 poster ()
Keywords: graph neural networks (GNN)
policy learning
planning
relational learning
Primary area: reinforcement_learning
TL;DR: Learning a relational policy to solve planning problems by ranking actions using a new graph representation and decoder architecture

Abstract: We propose a novel approach to learn relational policies for classical planning based on learning to rank actions. We introduce a new graph representation that explicitly captures action information and propose a Graph Neural Network (GNN) architecture augmented with Gated Recurrent Units (GRUs) to learn action rankings. Unlike value-function based approaches that must learn a globally consistent function, our action ranking method only needs to learn locally consistent ranking. Our model is trained on data generated from small problem instances that are easily solved by planners and is applied to significantly larger instances where planning is computationally prohibitive. Experimental results across standard planning benchmarks demonstrate that our action-ranking approach not only achieves better generalization to larger problems than those used in training but also outperforms multiple baselines (value function and action ranking) methods in terms of success rate and plan quality.

Graph Neural Network Based Action Ranking for Planning
Rajesh Mangannavar Oregon State University Corvallis, OR 97330, USA
Stefan Lee Oregon State University Corvallis, OR 97330, USA leestefforegonstate edu
mangamr&oregonstatee edu
Alan Fern Oregon State University Corvallis, OR 97330, USA
Prasad Tadepalli
Oregon State University Corvallis, OR 97330, USA
alan. fewn@oregonstate..... edu
prasad. waaaaaaaaaaa111rogostttataae edu
Abstract
We propose novel approach to learn relational policies for classical planning based on learning rank actions. We introduce explicitly captures action information and propose a Graph Neural Network (GNN) architecture augmented with Gated Recurrent Units (GRUs) learn action rankings. Unlike value-function based approaches that must learn globally consistent function, our action ranking method only needs learn locally consistent ranking. Our model is trained on data generated from small problem instances that are easily solved by planners and applied to significantly larger instances where planning is computationally prohibitive. Experimental results across standard planning benchmarks demonstrate that our action-ranking approach not only achieves better generalization to larger problems than those used in training but also outperforms multiple baselines (value function and action ranking) methods in terms of success rate and plan quality.
graph representation that
Introduction
Classical planning tackles the problem of finding action sequences to achieve goals in deterministic environments. While traditional planners can solve small problems optimally using search and heuristics, they often struggle with scalability in complex problems 2 17]- This has motivated research into learning general relational policies from small solved problems, which can then be applied to significantly larger instances [23]. The key insight behind learning baaning-bbsed based planning is that optimal solutions small problems often reveal patterns that generalize to bigger problems. For example, in Blocks World, solutions to 4 block problems can teach policy to stack blocks bottom-up that generalizes to problems with or more blocks. The advantage of relational learning is its ability to capture compositional structure, which in turn enable strong generalization
[3 6
9
Learning approaches in automated planning have traditionally focused learning heuristic functions to guide search algorithms. These methods typically learn a value function that estimates the distance the goal and integrate it within classical search algorithms like A or greedy best-first search. The learned heuristics help focus the search but still require explicit search during plan execution.
Recently, several neural approaches have been proposed in the planning domain. Some methods learn value functions to guide search processes 22 D. while others learn value functions that induce greedy policies by selecting actions leading to states with minimum estimated cost-to-go 24 23
39th Conference on Neural Information Processing Systems (NcurIPS 2025).

---

While these approaches show promise, they all face a fundamental challenge: value functions are not only complex and challenging learn, but since optimal planning is NP-hard in most domains 11 there is no reason to think that optimal value functions generalize to larger problem sizes. In our work, instead of trying to learn optimal value functions we focus on learning policy that ranks good actions higher in any given state.
Learning to rank approaches have shown promise in planning domains but have primarily focused on ranking states rather than actions. [T]] pioneered this direction by using RankSVM to learn state rankings using hand-crafted features. More recently, [3,, and [3] demonstrated that learning to rank states can be more effective than learning precise heuristic values, as the relative ordering of states is sufficient for guiding search. However, these approaches still fundamentally rely on search during execution, inheriting significant computational overhead. The other drawback is that, while ranking states is easier than learning the exact value function, they are still trying to learn a globally consistent state ranking function which is challenging. We overcome this issue in our work by learning only local ranking over actions in any given state instead of learning a ranking among all possible states. we explicitly represent
Unlike other action ranking approaches such as [19], [66. 15 and 25
action information in our input state representation.
Our work is inspired by the effectiveness of graph neural networks (GNNs) 20 to represent and
learn general relational policies such as [24 25 26 30 where GNNs have been shown to be able to learn well over state representations for planning problems [8] D. GNNs are especially suited for these types of problems as they can handle inputs of varied sizes and can learn from graphs of small size and generalize to larger graphs [1]. This is the property we are looking to exploit- - train a system on small sized planning problems where it is easy to run planners and collect data and use this learned model to solve larger problems that planners are too slow to solve while simplifying the learning problem by only learning local action rankings.
To achieve this, we introduce a novel architecture GABAR (GrAph neural network Based Action Ranking), which directly learns to rank actions rather than estimating value functions. GABAR consists of three key components: (1) an action-centrie graph representation of state that explicitly captures how objects participate in actions (2) GNN encoder that processes this rich representation. and (3) based decoder that sequentially constructs parameterized actions. Our key insight that ranking actions that are applicable in the same state often turns out to be easier and more generalizable than ranking states by their distances to the goals. Through experiments on standard benchmarks, we show that (a) GABAR achieves generalization to significantly larger problems than those used for training, and (b) it does markedly better on the larger problems when compared to value-function-bass methods or other methods that do not include action information in the graph.
2
Problem Setup
Classical planning deals with finding a sequence of actions that transform an initial state into goal state. A classical planning problem represented as a pair P (D, I). where D represents a first-order domain and I contains instance-specific information. The domain D consists of set of predicate symbols P with associated arities and set of action schemas A. Each action schema a E A is defined by set of parameters A(a) representing variables that can be instantiated, preconditions pre(a), add effects add(a) (a), and delete effects dal( The instance information is a tuple (0, so, G) where O is finite set of objects. so is the initial state represented where p E P and o, E O, and G is the goal condition also represented as a set of ground atoms.
set of ground atoms p(o1. .... 0&)
A state is a set of ground atoms that are true in that state. An action schema can be grounded by substituting its parameters with objects from O. A ground action a applicable in state s pre(a) C s, and results in successor state s' = (s' \ del( (dd( A solution or plan is sequence of applicable ground actions that transform the initial state 80 into a state satisfying the goal condition G. A relational policy maps a problem state to an action. The current paper addresses the following problem. Given a domain / and a set of training instances of different sizes and their solutions, learn relational policy that leads to efficient solutions for larger test instances from the same domain.

---

Oberr
Pick-up
Addie Sckena
V.
Selkct Beett ebject Oy
%o
obgect 'Oy
Unstack
Schwera A.
Object O2
Oirecc Ug
mien
Coral ttrve
Gooonded ARD,, Ogb
Preveasing
CRU
14
Graph representationn of PDOL State and Geal
procossing
Extraction
Figure 1: GABAR's architecture for action extraction. (a) Graph representation: The input PDDL problem is converted into graph with four types of nodes (predicate, object, action schema, and global) connected by predicate-object and action-object edges that encode state and grounded action information. (b) GNN encoder: Processes the graph through 7. rounds of message passing where edge, node, and global representations are sequentially updated (c) Action decoder: Uses the final global embedding to construct grounded action through GRU-based decoder sequentially first selecting an action schema, then iteratively choosing objects for each parameter position until complete grounded action is formed.
3 GNN Based Action Ranking
Learning general policies for classical planning domains requires learning select appropriate actions effectively to variable-sized states and generalize across problem instances. This section details each component of GABAR, the graph representation, the GNN encoder and the GRU decoder in detail and explains how they work together to enable effective action selection.
3.1 System Overview
Given a planning instance, in PDDL format 77, along with the set of ground actions, GABAR operates by first converting this to a graph structure that makes explicit the relationships between objects, predicates, and potential actions. This graph is then processed through our neural architecture to rank actions(as described in Fig [ Then, the highest-ranked applicable action is executed to reach the next state P, and the process repeats. To ensure that the execution terminates, the system maintains history of visited states and avoids actions that would lead to previously visited states. The exccution continues until either a goal state reached or a state reached with no unvisited successor states, or the maximum execution length (1000 in our experiments) is exceeded.
3.2 Graph Representation
We introduce a novel graph representation (shown in Fig 2) for classical planning tasks that captures the structural relationships between objects, predicates, actions, and the semantic information needed to effectively learn action ranking. Our representation edges E, node features X and edge features R.
(V, X, X, R) consists a set of nodes V,
The node set V Ou (g) where O, P,and represent sets of domain objects, grounded predicates (predicates instantiated in current and goal states), and action schemas, respectively, and is a global node that aggregates graph-level information. The edge set E Eped U Eact. where Epred the set of edges between predicates and their argument objects and similarly Exst is the set of edges between action schemas and their argument objects.
The node feature function X V + Rd maps each node to feature vector that encodes type and semantic information. The feature vector is constructed by concatenating several one-hot encoded segments. For any node E V, X (X) Xma Xprea (v) X (v)], where,
Node Features:
Xaype E {0, 133; One-hot encoding of node type (object, predicate, or action)
Xast {0, 13 I|lA One-hot encoding of action type (if v is an action node)

---

Action node
Pick-up
Unstack
R9
Predicate node
Object node
@1
C2
Q2
Predicate object edge
Start State
Goal State
Clear
G-ON(OS,O8)
On (03,02)
Clear
Action object edge
Figure 2: Example graph construction for a simplified blocksworld problem with only on and clear predicates. The left side shows the starting and goal states. The O nodes the object nodes. In the start state, O3 is on 02 which is on the table, and O1 is on the table. In the goal state, 03 is on O1 which is the table, and O2 is the table. The right side shows the constructed graph with action nodes (blue), object nodes (yellow), and predicate nodes (red). The "Pick-up" action connects to object O1, while the "Unstack" action connects objects 02 and O3. Predicate nodes show the current state ("Clear" for O1 and O3, "On (03,02)") and goal state ("G-ON(O3,00) 01)"). Blue edges represent action-object connections, while red edges represent predicate-object relationships.
Xred E 10.1) Encoding for predicates, where first PP bits indicate predicate type and next [P| bits indicate goal predicates (if is a predicate node)
Xajj E (0, 13 One-hot encoding of the object type (if an object node). the set of object types
The edge feature function R E + R* maps each edge to a feature vector that encodes the type of edge and the information about the role. For any edge e E, R(e) [Ryyee (ee || [e)( where,
Edge Features:
*
RRype E {0, 1j:: One-hot encoding of edge type (predicate-object or action-object)
RRpeed E {0, 10"1 For predicate- object edges, one-hot encoding of argument position (m is max predicate arity)
Ract E {0, 1)(m+)P1); For action-object edges, concatenation of:
- One-hot encoding of parameter position in action schema (m bits)
Binary vector indicating which predicates are satisfied by the object grounded action (IP) bits). We only encode edge information for the actions that are applicable in the current state.
Global Features: The global node g is initialized with a zero vector in R where is the chosen hidden representation dimension. This node be used to aggregate and propagate graph-level information during message passing. This global node is essential in passing information at each round from nodes that far apart. Hence, while nodes get their location information from neighboring edges, they also receive some global context at each round of the GNN ensuring that the number of GNN rounds does become bottleneck in passing information in large graphs. This is important since, as problems get larger the graph size grows, but the number of GNN rounds stays constant. The global node ensures all nodes and edges in the graph have some global context each step.
This graph representation captures both the structural and semantic information necessary for learning planning heuristics while maintaining bounded feature dimension independent of problem size. The node features encode type and semantic information, while the edge features capture the relationships between objects, predicates, and actions in the planning domain.
3.3 Neural Architecture
Our neural architecture processes this graph representation through multiple components designed to handle the challenges of processing variable-sized inputs, capturing long range dependencies between objects and actions, and making sequential decisions to select actions and their arguments as shown in algorithm]
!
We detail each component below:
3.3.1 GNN Encoder
Graph Neural Networks (GNNs) 20 are particularly well-suited for encoding states in planning problems they naturally process relational structures while being invariant permutations and

---

Procedure GABAR(G -V,,)))=V)))))
Procedure DECODER Hev
I: Initialize: (vile (el g
I: h1 = -GRUgg"
2: // GNN Encoder
2: Select action schema
3: for 1= = L do
3: score(a) MLP((h Ô v for each E A
4: // Edge Update
4: a- = arg maX softmax(score(c))
5: v(i,)) E E: of th (legy) vi v/1
h2 = GRU(H,, vz.)
6: Node Update
Select parameters
7: WEV: V: v 1+1 &
7: for i to required parameter count do
J E ((i))):
8: score(o) = MLP(h;+1 for each E O
8: // Global Update
9: o = arg max softmax softmax(score(o))
9: = g (gl AGG(L [+1 v));
10: h4+2 GRU(h vo:
AG E E)))
11: return 0j 0z o
10: return DECODER(g', ( Nev, A, Algorithm 1: Graph Attention-Based Action Ranking (GABAR)
handling varying input sizes 29 This allows them to learn patterns that generalize across different problem instances within the same domain, regardless of the number of objects involved. The key insight is that planning states are inherently relational objects interact through predicates and actions and GNNs can capture these relationships through message passing between nodes and edges. The GNN encoder (Algorithm left side) transforms the input graph into learned embeddings.
Initialization (line 1): We initialize node features, edge features, and global feature vector from the input graph. Message Passing (lines 3-9): For iterations, the encoder performs the following three update steps. 1) Edge Update (line 5): Each edge updates its representation by combining features from its connected elements. 2) Node Update (lines 7-8); Each node aggregates information from its neighboring edges along with global context. 3) Global Update (lines 9-10); The global vector is updated by aggregating information from all nodes and edges.
The aggregation function (AGG) employs attention mechanisms to weight different elements ac- cording to their relevance. This architecture makes several key design choices motivated by the planning domain. First, we explicitly model and update edge representations because edges in graph capture crucial information about action applicability. This edge information helps guide the model toward selecting valid and effective actions. Second, we include global node that rapidly propagate information across the graph. This is important because without the global node, information would need to flow through many message-passing steps reach distant parts of the graph. The global node acts as shortcut, allowing the model to maintain a comprehensive view of the planning state passing have been performed, the final global node embedding g'+1 captures the relevant planning context needed for action selection.
as the number of objects and relations grows. After I, rounds of message
3.3.2 GRU Decoder
The GRU-based decoder (Algorithm) T right side) uses the encoded graph to select an action and its parameters. Initialization (line 1): The decoder initializes its hidden state using the global graph embedding and a zero vector. Action Schema Selection (lines 3-5): The decoder computes a score for each potential action schema (line 3). It then Selects the highest-scoring action (line 4) and updates the hidden state with the selected action's 's features (line 5).
Parameter Selection (lines 7-10): For each required parameter position, scores computed for all objects using the current hidden state (line 8). The highest-scoring object is selected as the parameter (line 9). The hidden state is updated with the selected object's 's features (line 10). Output (line 11): The decoder returns the complete action grounding.
This autoregressive approach ensures that each parameter selection is conditioned on the graph structure, the selected action schema, and all previously selected parameters. By updating the GRU hidden state with each selection, the model captures dependencies between different components
5

---

of the action. We repeat this greedily until all action parameters have been extracted. Since greedy parameter selection often too myopic, we employ beam search to explore multiple choices in parallel. For a beam width k, at each step, we maintain the k highest-scoring partial sequences. The final output is ranked list of action groundings (a, .1....; ,o,) along with their accumulated scores. This process of GRU-based decoding helps generalize the framework to handle actions with any arity, as we can extract as many objects as necessary for the action selected in the first step of the decoding. Hence, at any given state, we can the decoder to extract the ranking over the set of actions with different arity all at once. This aligns with our goal learning to rank fully grounded actions rather than independently optimizing each argument (extended beam search version of the decoder that maintains multiple candidate action groundings in parallel is provided as algorithm 2 in the Appendix). While training optimizes for selecting the optimal action, the learned model provides a ranking of the top grounded actions during execution. The planner then selects the first legal action in the current state according to the ranking. It also the ranking avoid cycles if an action leads to a state previously visited, then the next best action is considered.
3.4 Data Generation and Training
For each planning domain, we generate training data by solving set of small problem instances using an optimal planner. Each training example consists of a planning state s, goal specification G, and the first action a" from the optimal plan from to G. For states with multiple optimal actions, we randomly select one to avoid biasing the model.
The state-goal pairs are converted into our graph representation G = (V, E, X, R) as described in the graph representation section. For each action a" the training data, we create supervision signals in the form of:
Da A one-hot vector over the action schema space indicating the correct action type
Yo = (Mol:-.., Yok J:
sequence of k one-hot vectors over the object space, where k is the maximum number of parameters any action can take, indicating the correct objects for each parameter position
For action schema selection, the model needs to learn to assign the highest score to the correct action schema among all possible schemas. For each parameter position, the model needs to learn assign the highest score to the correct object among all candidate objects. This is done using the following loss function.
Loss Function. Given a training instance (G, yo: Vo). GABAR computes action scores 8a for all possible action schemas and object scores So, for each parameter position i. The total loss is computed as J. = I-action + Trabjects, where, Trabjects is the sum of cross-entropy losses between softmax(s,, (x.,) and yo: for each parameter position i.
Training Procedure. For all domains, we train the model using the Adam optimizer with learning rate of 0.0005, 9 rounds of GNN, and batch size of 16, hidden dimensionality of 64. Training proceeds for a maximum of 500 epochs, and we select the model checkpoint that achieves the lowest loss on the validation set for evaluation. It takes between 1-2 hours to train model for each domain on an RTX 3080.
4 Experiments
We evaluate GABAR's 's performance across a diverse set of classical planning domains. Our experi- ments aim to assess both the quality of learned policies and their ability generalize to significantly larger problems than those in training. We selected eight standard planning domains that present different types of structural complexity and scaling dimensions. The domains are BlocksWorld Gripper, Miconic, Spanner, Logistics, Rovers, Grid and Visitall (More details about domains and number of training instances in appendix[A.]
We divide the test set for each domain into separate subsets, easy, medium, and hard with increasing difficulty with problem sizes as defined in table [ along with the training and validation dataset sizes. Each test subset has 100 problems. contrast, the training dataset consists of problems smaller and simpler than the ones found in the easy subset.

---

Table 1: Distribution of problem sizes across train, validation, and test datasets. The ranges indicate the number of objects/variables defining each domain's problem complexity. * In Visitall and Grid, size refers to number of cells
Train
Val
Test
Train
Val
Test
domain
domain
casy
med
hard
easy
med
hard
Blocks
[6.9] [10]
[11, 20
[21,30]
[31, 10]
Rovers
[3,
[10]
[11,30]
[31, 50]
[51, 70]
Gripper
[6, 15] [17]
[20, 40
[41, 60
661 100]
Visitall
[9,36]
[49]
[50, 100
[101, 200
201, 400
Miconic
[1,9]
[10]
[20, 40)
[41, 60
61, 100)
Grid*
[25, 49] [63]
[64, 100
1100, 125
125, 154]
Spanner
[2.9] [10]
[11, 20] [21,30] (1,44)
Logistics
[1,
[8] [15. 20
[21, 25]
(26,30)
We evaluate GABAR against three state-of-the-ar approaches for learning generalized policies: GPL, ASNets, and GRAPL. Each represents different architectural paradigm for tackling generalized planning.
4.1 Baseline Approaches
GPL. (Generalized Policy Learning) 24 learns value functions over states using GNNs. It selects
actions by identifying unvisited states with the lowest estimated cost-to-goal. GPL attempts to learn globally consistent value function by minimizing the regularized Bellman error (V(s) (1
mis) (ss))] + max(0, V*(s) - -V)) + max(0, (s) - 8s)(s)} where s is state and (s)
value function defined as cost to goal.
ASNets (Action Schema Networks) 27 employs a neural network with alternating action and proposition layers. Each layer contains modules that connect only to related modules in adjacent layers. ASNets shares weights across modules of the same action schema or predicate, enabling generalization across problems of varying sizes but limiting its reasoning to fixed-depth receptive field.
GRAPL (Graph Relational Action Ranking for Policy Learning) [16] Iearns to rank actions using canonical abstractions where objects with identical properties are grouped together. Its neural network predicts both action probabilities and plan length estimates but lacks the explicit action-object graph structure and conditional decoding mechanisms of our approach.
Ablations: To assess each component's 's contribution to GABAR, we conducted ablation experiments with three variants:
GABAR-ACT: Removes action nodes and action-object edges from the graph, using only object and predicate nodes for decision- decision-making.
GABAR-CD: Eliminates conditional decoding by selecting action parameters independently rather than sequentially. This tests the importance of dependencies between action parameters.
GABAR-RANK: Replaces action ranking with a value function learning objective while maintain- ing our graph representation.
These ablations isolate our key innovations innovaaions-aactton-ceete graphs, GRU-based conditional decoding, and action ranking- to measure their individual impact on performance.
Evaluation Metrics. We evaluate GABAR using two primary metrics:
Coverage (C): The percentage of test instances successfully solved within a 1000-step limit.
Plan Quality Ratio(P): Ratio of plan length produced by Fast Downward (FD) [14] planner to the plan length produced by the learned policy. FD is run with fd-lama-fire setting. We chose this satisficing configuration over optimal planners since optimal planners fail to solve most test problems within a reasonable time. While this means we cannot guarantee the optimality of the reference plans, it provides practical baseline for assessing solution quality.
High coverage on larger instances demonstrates the model's 's ability to learn general action selection strategies, while plan quality ratio reveals whether these strategies produce efficient plans as problems scale up.
7

---

Results and Discussions
Table 2: Coverage (C) and plan quality ratio (P) across different domains and difficulty levels.
Turqoise color intensity for C values indicates coverage score (Only values above 50% are highlighted: Light: 50-74%, Medium: 75-89%,
Dark: 90-10090 P values are highlighted in violet with similar thresholds (No highlight: 0-0.49, Light: 0.5-0.74, Medium: 0.75-0.99, High: 1.0+). Columns are grouped into Baselines and Ablations. Combined rows show averages across all domains. only non-zero values from their respective domains were considered
Baselines
Ablations
GPL
ASNers
GRAPI
GABAR
GATAR-ACT
GABAR-CD
GABAR-RANK
Domain
Diff
C1
Pt
Cf
Pt
C1
Pf
C1
Pt
Ct
P1
C1
Pt
C1
Pt
E
100
1.1
100
1.6
64
0.65
100
1.5
44
0.65
100
0.92
29
0.79
Blocks
45
0.68
100
1.5
48
0.44
100
1.6
14
0.49
92
0.81
21
0.71
H
10
0.33
92
1.4
38
0.28
100
1.7
4
0.35
81
0.80
0.61
E
0.97
100
1.0
0.56
100
1.0
35
0.55
0.88
Miconic
M
37
0.56
100
0.98
65
0.54
100
0.97
18
0.33
94
0.86
29
0.37
0.29
90
0.92
60
0.49
100
0.95
2
0.27
0.83
16
0.29
E
73
1.1
78
0.86
22
0.65
94
1.1
31
0.65
87
0.98
57
0.82
Spanner
42
0.56
60
0.69
0.55
93
0.99
11
0.27
81
0.93
42
0.77
H
0.18
42
0.61
0
89
0.91
0
62
0.79
12
0.45
E
100
1.0
78
0.98
26
0.95
100
1.1
31
0.56
95
1.0
55
0.58
Gripper
0.85
54
0.91
12
0.67
100
0.99
23
0.40
92
0.93
43
0.41
H
21
0.74
42
0.88
0
100
0.96
9
0.28
87
0.86
21
0.33
E
1.3
94
0.96
92
1.1
93
1.1
72
1.2
52
0.64
Visitall
M
15
0.76
86
0.93
88
1.0
91
1.0
64
0.93
89
1.1
46
0.56
64
0.81
78
0.99
88
1.1
44
0.67
0.54
E
74
0.89
52
0.81
20
0.38
100
0.91
21
0.56
79
0.87
17
0.54
Grid
M
17
0.61
45
0.66
3
0.28
97
0.85
8
0.46
0.65
12
0.28
H
0
0.60 21
0
92
0.74
0
54
0.53
E
56
0.61
39
0.71
32
0.81
90
0.75
12
0.64
31
0.86
41
0.65
Logistics
0.21
22
0.55
0.45
76
0.65
3
0.49
0.54
0.49
H
0
0.39 4
0
71
0.59
O
0.35
0
E
0.99
67
0.96
21
0.35
87
1.0
22
0.75
0.81
33
0.67
Rovers
M
0.32
56
0.87
5
0.19
82
0.96
6
0.66
37
0.63
9
0.56
31
0.64
0.97
0
E 79.1
0.98
76
0.98
43.5
0.67
95.5
1.04
33.5
0.69
0.93
40.2
0.67
Combined M
28.5
0.56
65.4
0.88
29.3
0.51
92.2
1.01
18.4
0.50
72.7
0.80
27.8
0.51
0.39*
48.5
0.78
22.1
0.58
89.2
0.99
7.4
0.39
12.1
0.44*
Table 2 shows the performance of GABAR, its ablations, and the baseline approaches across all domains. The results demonstrate significant differences in generalization capabilities and solution quality.
5.1 Generalization Performance
GABAR generalizes remarkably well across all domains, with coverage dropping minimally from 95.5% easy problems 89.5% on hard problems. This generalization is particularly evident in domains like Visitall, where GABAR solves problems times larger than those in training. On World, Gripper, and Miconic, GABAR achieves 100% success rate all difficulty levels.
Even in complex domains requiring multi-relation features (Grid, Logistics) or higher arity predi- cates (Rovers), GABAR maintains strong performance with success rates of 92%, 62%, and 77%

---

respectively on hard instances. This demonstrates that our graph structure effectively encodes critical problem information, and the decoder successfully captures relationships between actions and their parameters. We now analyze GABAR against baselines and relevant ablation results, highlighting how our design choices contribute to performance improvements.
Action Ranking vs. Value Function Learning: GPL uses GNNs to learn value functions over states, aiming to produce globally consistent estimates of cost-to-goal [24]. As problems grow larger, maintaining these consistent estimates becomes significantly more challenging. GPL's coverage drops to 0% on hard instances of Logisties and Visitall where GABAR maintains 71% and 88% coverage. Our ablation GABAR RABAR-RANK, which replaces action ranking with value function learning while keeping our graph structure intact, shows similar pattern coverage decreases from 89.2% to just 12.1% 1% on hard problems. The PQR also drops from 0.98 in easy problems to 0.39 in hard problems for GPI., 0.67 0.44 for GABAR-RANE This parallel between GPL. and RABAR-RANK confirms that directly ranking actions is more effective than learning value functions.
Conditional vs. Non-conditional Decoding: GRAPL also learns action rankings but uses an abstract state representation without explicit modeling of action parameter dependencies [16. While conceptually similar to our approach, GRAPL achieves only moderate performance on easy instances (43.5% coverage) and struggles on harder problems (22. % coverage) compared to GABAR's s 95.5% and 89.2%. Our ablation GABAR-CD. CD, which removes our conditional decoding mechanism, shows a similar degradation coverage drops from 89.2% to 60.0% on hard problems overall, with particularly dramatic decreases in complex domains like Logistics (from 62% to 21%). This comparison highlights the critical importance of our conditional GRU-based decoder for handling complex dependencies in domains where objects participate in multiple predicates simultaneously (e.g., a package being in both city and a vehicle). The decoder learns relationships between parameter selections by conditioning each object choice on previously selected objects, enabling the model to capture complex inter-parameter relationships that GRAPL cannot.
Action-Centric Graph Structure: ASNets employs alternating action and proposition layers with a fixed-depth receptive field (27). limiting its ability to reason about long chains of dependencies. problems, it generalizes poorly to larger instances-achieeee only 21% 4%, and 31% coverage on hard instances of Grid, Logistics, and Rovers, compared to GABAR's 92%, 62%, and 77%. Although we don't have a perfect ablation parallel for ASNets, our GABAR-ACT ablation (removing action nodes) shows catastrophic perfor- mance drops from 95.5% to 33.5% on easy problems and from 89.2% to just 7.4% on hard problems. This suggests that explicit action-object relationship modeling in the graph structure is critical for robust generalization.
While ASNets performs reasonably on
These comparisons demonstrate that GABAR's superior performance stems from the synergistic combination of three key ideas: (1) an centrnc graph representation that captures relationships between actions and objects, (2) conditional decoding that models dependencies between action parameters, and (3) direct action ranking that avoids the challenges of learning globally consistent value functions. The ablation studies confirm that each component addresses these limitations present in current approaches to generalized planning.
6 Conclusion and Future Work
We presented GABAR, a novel graph-based architecture for learning generalized policies in classical planning through action ranking. Our key contributions include (1) an action-centric graph represen- tation that explicitly captures action-object relationships, (2) GNN architecture augmented with global nodes and GRUs for effective information propagation, and (3) sequential decoder that learns to construct complete grounded actions. First, GABAR shows strong generalization capabilities, successfully solving problems significantly larger than those used in training. The system maintains high coverage (89%) even on the hardest test instances that are up to 8 times larger than training prob- lems. This generalization is particularly significant in complex domains like logistics and grid that require coordinating multiple entities. Second, our extensive baseline and ablation studies validate that this superior performance stems from the synergistic combination of our core design choices. Our comparison with the value-based GPL baseline and our GABAR-RAND ablation confirms that directly ranking local actions is a more robust and generalizable strategy for large problems than learning& globally consistent value function. Furthermore, the significant performance gap between
9

---

GABAR and both the GRAPL baseline and our GABAR-CD (non-conditional ablation highlights the critical importance of the conditional decoder for handling complex action-parameter dependencies. Finally, comparisons against ASNets and the failure of the GABAR-ACT (no action nodes) ablation show that explicitly modeling action-object relationships within the graph is essential for robust generalization. The primary challenge for the proposed method is the graph representation's 's growth rate, particularly for domains with high-arity actions or predicates. Future work could explore more compact representations while maintaining expressiveness and investigate ways of pruning irrelevant actions in the graph. Other future work could also include expanding the representation to handle uncertainty and solve more real- world problems such as object rearrangement.
7 Acknowledgments
The authors acknowledge the support of Army Research Office under grant IN11NF2200251
References
[1] Dillon Chen, Sylvie Thiébaux, and Felipe Trevizan. Learning domain inndin-independent heuris- ties for grounded and lifted planning. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 38, pages 20086, 2024.
[2] Dillon Z Chen, Pulkit Verma, Siddharth Srivastava, Michael Katz, and Sylvie Thiébaux. Ai planning: A primer and survey (preliminary report). arXiv preprint arXiv:2412.05522, 2024.
[3] Leah Chrestien, Stefan Edelkamp, Antonin Komenda, and Tomas Pevny. Optimize planning heuristics to rank, not to estimate cost-to-goal. Advances in Neural Information Processing Systems, 36, 2024.
[4] Sašo Džeroski, Lue De Raedt, and Kurt Driessens. Relational reinforcement learning. Machine learning, 43:7-52, 2001.
[5] Kutluhan Erol, Dana S. Nau, and V.S. Subrahmanian. Complexity, decidability and undecid- ability results for domain-independent planning. Artificial Intelligence, 76(1):75-88, 1995. Planning and Scheduling.
[6] Alan Fern, Sungwook Yoon, and Robert Givan. Approximate policy iteration with policy language bias. Advances in neural information processing systems, 16, 2003.
[7] Maria Fox and Derek Long. Pdd12. 1: An extension to pddl for expressing temporal planning domains. Journal of artificial intelligence research, 20:61-124, 2003.
[8] Sankalp Garg, Aniket Bajpai, et al. Size independent neural transfer for rddl planning. In Proceedings the International Conference Automated Planning and Scheduling, volume 29, pages 631-636, 2019.
[9] Sankalp Garg, Aniket Bajpai, et al. Symbolic network: generalized neural policies for relational mdps. In International Conference on Machine Learning, pages 3397-3407. PMLR, 2020.
[10] Caelan Reed Garrett, Leslie Pack Kaelbling, and Tomás Lozano-Pérez. Learning to rank for synthesizing planning heuristics. arXiv preprint arXiv: 1608.01302, 2016.
[11] Naresh Gupta and Dana S Nau. On the complexity of blocks-world planning. Artificial intelligence, 56(2-3):223222 254, 1992.
[12] William L Hamilton. Graph representation learning. Morgan & Claypool Publishers, 2020.
[13] Mingyu Hao. Felipe Trevizan, Sylvie Thiébaux. Patrick Ferber, and Jörg Hoffmann. Guiding gdfs through learned pairwise rankings. In Thirty-Third International Joint Conference on Arti- ficial Intelligence [IJCAI-24), pages 6724-6732. International Joint Conferences on Artificial Intelligence Organization, 2024.
[14) Malte Helmert. The fast downward planning system. Journal of Artificial Intelligence Research, 26:191-246, 2006.
10

---

[15] Jaromír Janisch, Tomáš Pevný, and Viliam Lisý. Symbolic relational deep reinforcement learning based on graph neural networks and autoregressive policy decomposition. arXiv preprini arXiv:2009. /2462, 2020.
[16] Rushang Karia and Siddharth Srivastava. Learning generalized relational heuristic networks for -agostiag planning. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 35, pages 8064-8073, 2021.
[17] Rajesh Mangannavar, Alan Fern, and Prasad Tadepalli. Hierarchical object-oriented pomdp planning for object rearrangement. arXiv preprint 2xXi::4412.01348 2024.
[18] Rajesh Mangannavar and Prasad Tadepalli. Gammazero: Learning to guide pomdp belief space search with graph representations. arXiv preprint axXiv25510.44335 2025.
[19] Or Rivlin, Tamir Hazan, and Erez Karpas. Generalized planning with deep reinforcement learning. arXiv preprint wrXv::0055002355, 2020.
[20] Franco Scarselli, Marco Gori, Ah Chung Tsoi, Markus Hagenbuchner, and Gabriele Monfardini. The graph neural network model. IEEE transactions neural networks, 20(1):61-80, 2008.
[21] Jendrik Seipp, Álvaro Torralba, and Jörg Hoffmann. PDDL generators. https://doi.org
10. 10..528/zenodo. 6382173 33322211.dod..626333333
2022.
[22] William Shen, Felipe Trevizan, and Sylvie Thiébaux. Learning domain-independent planning heuristics with hypergraph networks. In Proceedings of the International Conference on Automated Planning and Scheduling, volume 30, pages 574-584, 2020.
[23] Simon Ståhlberg, Blai Bonet, and Hector Geffner. Learning general optimal policies with graph neural networks: Expressive power, transparency, and limits. In Proceedings of the International Conference on Automated Planning and Scheduling, volume 32, pages 629-637, 2022.
[24] Simon Ståhlberg, Blai Bonet, and Hector Geffner. Learning generalized policies without supervision using gnns. arXiv preprinl arXiv:2205.06002, 2022.
[25] Simon Ståhlberg, Blai Bonet, and Hector Geffner. Learning general policies with policy gradient methods. In Proceedings of the International Conference Principles of Knowledge Representation and Reasoning, volume 19, pages 647-657, 2023.
[26] Simon Stählberg, Blai Bonet, and Hector Geffner. Learning general policies for classical planning domains: Getting beyond 22 arXiv preprint arXi::2403.11734 2024.
[27] Sam Toyer, Sylvie Thiébaux, Felipe Trevizan, and Lexing Xie. Asnets: Deep learning for generalised planning. Journal of Artificial Intelligence Research, 68:1-68, 2020.
[28] Karthik Valmeckam, Kaya Stechly, Atharva Gundawar, and Subbarao Kambhampati. A system- atic evaluation of the planning and scheduling abilities the reasoning model ol. Transactions on Machine Learning Research, 2025.
[29] Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? arXiv preprint arXiv: 1810.0086, 2018.
[30] Vinicius Zambaldi, David Raposo, Adam Santoro, Victor Bapst, Yujia Li, Igor Babuschkin, Karl Tuyls, David Reichert, Timothy Lillicrap, Edward Lockhart, et al. Relational deep reinforcement learning, arXiv preprint arXiv: 100.0110000018000, 2018.
A Appendix
A.1 Domain descriptions
Blocks World involves manipulating blocks to achieve specific tower configurations. The domain's 's complexity scales with the number of blocks (6-9 blocks for training/validation, 10-40 blocks for testing).
11

---

Table 3: Number of training datapoints per domain
Domain
Training Datapoints
Blocksworld
3,348
Gripper
6,287
Miconic
4,458
Spanner
3,801
Logistics
6,556
Rovers
3,874
VisitAll
3,654
Grid
6,880
Gripper requires a robot with two grippers to transport balls between rooms. The domain scales primarily with the number of balls to be moved (5-17 balls for training/validation,, up 100 balls for testing).
Miconic involves controlling elevator to transport passengers between floors. The domain complexity increases along two dimensions: the number of passengers (1-10 for training/validatinn 20-100 for testing) and the number of floors (2-20 for training/validation, 11-30 for testing).
Logisties involves transporting packages between locations using trucks (for intra-city transport) and airplanes (for inter-city transport). The domain scales with both the number of cities (4-8 for training/validation, 15-30 for testing) and packages (3-9 for training/validation. 10-24 for testing).
Visitall requires an agent to visit all cells in grid. The domain scales with grid size (9-49 cells for training/validation, up 400 cells for testing testing problems times larger than the training dataset).
Grid involves navigating through grid where certain doors are locked and require specific keys to open, The number of locks (3) and keys (5) remain the same across training and testing while varying the size of the grid (7x9 for training/validationn to 1 x 14 for testing 1500% increase in cells).
Spanner requires tightening nuts one end of corridor with spanners collected along the way. Number of locations varies from 10-20 in training and testing, the number of spanners varies from 2-10 training and to 40 in testing.
Rovers requires multiple rovers equipped with different capabilities to perform experiments and send results back the lander. Training and validation instances use 2-5 rovers and 3-10 waypoints; those for testing have 3-7 rovers and 1170 waypoints.
Table 3 contains information about number of datapoints used for each domain All problems generated using openly available PDDIL-generators 21
A.2 Ablations
We present more ablations on our method in this section to further analyze the contribution of different components in our GABAR architecture. The two configurations tested are:
An ablated version of GABAR that removes the global node from the graph neural network. Without the global node, the model lacks a centralized representation that aggregates infor- mation across the entire state, potentially limiting its ability reason about complex relationships spanning multiple objects.
GABAR-G:
GABAR-ACT CD: A severely limited version that removes both the action representation from the graph and the conditional decoding mechanism. This baseline lacks the capability to explicitly represent actions in the state graph and cannot condition parameter selection on previously chosen actions, effectively testing the importance of both structured action representation and sequential decision-making. Results Discussion
'Code
com/Learning--..... worliinng-----oo for- Seag-Deeision--Man Dataset submitted as supplementary mate-
GABAR Graph- based- action ranking for planning
rial
12

---

Table 4: Performance across domains and difficulty levels. Coverage (C) indicates percentage of test instances solved within 1000 steps. Plan Quality Ratio (P) reported only for solved instances. Turqoise color intensity for C values indicates coverage score (Only values above 50% highlighted). values are highlighted violet with similar thresholds. Combined rows show averages across all domains. (*) only non-zero values from their respective domains considered.
ACT_CD
GABAR
GABAR-G
Domain
Diff
C1
Pt
Ct
Pf
Cf
Pf
E
0.33
100
1.5
100
1.2
Blocks
M
0.31
100
1.6
88
1.2
100
1.7
32
0.70
E
0.32
100
1.0
95
0.95
Miconic
M
0.27
100
0.97
70
0.87
HI
100
0.95
56
0.73
E
12
0.43
94
1.1
82
0.93
Spanner
0.24
93
0.99
74
0.81
H
89
0.91
54
0.62
E
1.5
0.58
100
1.1
95
1.0
Gripper
M
0.34
100
0.99
92
0.95
100
0.96
77
0.90
E
0.58
93
1.1
77
0.96
Visitall
M
19
0.55
91
1.0
66
0.83
H
16
0.48
88
1.1
29
0.51
E
100
0.91
79
0.83
Grid
97
0.85
68
0.62
H
0
92
0.74
33
0.41
E
90
0.75
45
0.43
Logistics
M
76
0.65
22
0.33
H
71
0.59
4
0.21
E
0.45
87
1.0
77
0.85
Rovers
M
0
82
0.96
72
0.79
H
77
0.97
55
0.65
E
0.44
95.5
1.04
80.2
0.89
Combined
M
4.5
0.34*
92.2
1.01
69.2
0.79
H
0.48
89.2
0.99
42.5
0.59
The results from Table cleaary demonstrate the effectiveness of our complete GABAR architecture compared to its ablated counterparts:
Overall Performance: GABAR significantly outperforms both ablated versions across all domains and difficulty levels. With average coverage of 95.5%, 92.2%, and 89.2% for easy, medium, and hard problems respectively, GABAR demonstrates robust generalization capabilities.
GABAR v/s GABAR-G The dramatic performance drop from GABAR to GABAR-G (especially on hard problems where coverage falls from 89.2% to 42.5%) highlights the critical importance the global node in architecture. This component enables effective information aggregation across the entire state graph, substantially improving the model's 's ability to handle complex planning scenarios. This degradation in quality suggests that the global node plays crucial role in helping the model leam strategic action selection rather than just locally reasonable choices.
The extremely poor performance of GABAR- ACT _CD (with coverage below 10% most domains and near-zero on harder problems) confirms that both action representation within the graph and conditional decoding essential components. Without them, the
GABAR v/s GABAR-ACT_ON
13

---

model fails to capture the relationship between actions and their parameters or to maintain consisteney in sequential decisions.
Plan Quality: Beyond just solving more problems, GABAR consistently generates higher-quality plans (as measured by PQR) compared its ablated counterparts. This indicates that the full model not only finds solutions but discovers more efficient paths to the goal.
A.3 LLM Comparisons
To evaluate the relative capabilities of our approach against tfae-of-theear language models, conducted experiments using OpenAl's O3 model and Semini-2.5-PPr (both released in 2025). Following the methodology of (28), adopted their One-Shot prompting technique to generate prompts for our planning problems. We extracted the generated plans from model responses and validated them against problem constraints.
Table 5: Comparative performance of GABAR against state-of-the-art Large Language Models (OpenAI-O3 and Gemini-2.5-Pro using a One-Shot prompting methodology. GABAR substantially outperforms both LLMs in Coverage (Cf) and Plan Quality (Pt) across all difficulties. The performance gap widens significantly on medium (M) and hard (H) problems, where LLM coverage collapses, highlighting their limitations in complex problems. Turqoise color intensity for C values indicates coverage score (Only values above 50% are highlighted). values are highlighted in violet with similar thresholds. Combined from their respective domains were considered.
show averages across all domains. (*) only non-zero values
OpenAT-O3
Gemini2.5 2.5-Pro
GABAR
Domain
Diff
Ct
Pt
Ct
Pf
Cf
Pt
E
73
1.03
81
1.1
100
1.5
Blocks
0.95
0.86
100
1.6
HI
4
0.61
12
0.81
100
1.7
E
56
0.81
79
0.86
100
1.0
Miconic
0.69
36
0.58
100
0.97
H
12
0.51
100
0.95
F.
38
94
1.1
Spanner
M
13
0.77
10
0.64
93
0.99
H
89
0.91
E
39
0.89
55
0.95
100
1.1
Gripper
0.75
12
0.81
100
0.99
H
100
0.96
E
37
0.88
43
0.97
93
1.1
Visitall
0.73
27
0.96
91
1.0
H
88
1.1
E
0.81
0.67
100
0.91
Grid
M
7
0.71
13
0.56
97
0.85
92
0.74
E
0.77
13
0.68
90
0.75
Logistics
M
76
0.65
H
71
0.59
E
12
0.78
43
0.45
87
1.0
Rovers
0.33
82
0.96
H
0
77
0.97
E Combined
33.4
0.85
44.0
0.8
95.5
1.04
11.6
0.77
17.1
0.68*
92.2
1.01
H
0.4
0.61
1.5
0.51*
89.2
0.99
14

---

Table presents the comparative results. GABAR demonstrates substantially superior performance across all difficulty levels. On easy problems, while Gemini-2.5-Per achieves the highest coverage among LLMS at 44.0%, GABAR reaches 95.5% coverage with better plan quality (1.04 vs 0.80). OpenAI-O3 achieves 33.4% coverage with a plan quality of 0.85.
The performance gap widens substantially on medium-difficulty problems, Gemini-2.5- --o maintains 17.1% coverage while OpenAI-O3 drops 11.6%, compared to GABAR's s 92.2%. Both LLMs also show degraded plan quality (0.68-0.77) while GABAR maintains 1.01. This suggests that as planning complexity increases, language models struggle with both solution generation and plan quality.
On hard problems, both language models demonstrate severe limitations. OpenAI-O3 achieves only 0.4% coverage (solving problems in single domain: Blocks), while Gemini-2.5 2.5-Prr reaches 3.0% (succeeding in Blocks and Miconic). Their plan quality on these rare successes remains substantially lower (0.61 and 0.51 respectively) compared to GABAR's consistent 0.99 across all domains.
These results highlight fundamental differences in approach. While LLMs rely on pattern matching from training data and struggle with systematic reasoning over complex state spaces, GABAR's architecture explicitly learns structural relationships between actions, objects, and predicates through its graph-based representation. This structural inductive bias, combined with conditional decoding mechanisms, enables GABAR to maintain robust performance as problem complexity scales a critical requirement for practical planning applications.
A.4 Plan Length and Coverage Analysis
In addition to coverage metrics, we analyze the efficiency of generated plans through plan length measurements. Plan length represents the number of actions in the solution found by each method, with shorter plans indicating more efficient solutions. However, raw plan length comparisons are fundamentally misleading when methods achieve different coverage rates because methods that solve fewer problems inherently select for simpler instances within each difficulty category, artificially deflating their average plan lengths. To address this selection bias, report the Plan Quality Ratio (PQR) as our primary efficiency metric. PQR is computed as the ratio of the learned policy's 's plan length to Fast Downward's 's plan length, but crucially, only for problems successfully solved by both methods. This metric eliminates the confounding factor of different methods tackling different problem subsets-a method that solves only 10% of the easiest problems might show excellent raw plan lengths, but its PQR reveals the true efficiency when compared fairly on the same problem instances. For this reason, PQR serves the main plan quality metric throughout our evaluation, providing meaningful comparisons even when coverage rates differ substantially between methods.
A.4.1 Understanding Plan Length in Context of Coverage
We present the Plan length (PL.) results for all baselines and GABAR in Table GABAR demonstrates high efficiency when coverage differences are properly contextualized. While GABAR does not always achieve the absolute lowest plan lengths, its performance becomes exceptional considering that it consistently solves significantly more problems than competitors across the entire spectrum of problem complexity.
The apparent discrepancies in plan length are largely explained by coverage differences between methods. When GPL achieves lower plan length of 27 on Spanner- compared to GABAR's 31, GPL only covers 73% of problems while GABAR covers 94%. Similarly, on Visitall-Easy. GPL achieves a plan length of 79 with only 69% coverage, while GABAR produces plans of length 103 but solves 93% of problems. The additional problems that GABAR solves likely represent more complex instances requiring longer plans, explaining the higher average plan length.
When examining cases with comparable coverage, GABAR's plan length performance becomes more impressive. On Blocks-Medium and Blocks-Hard where GABAR maintains 100% coverage compared to ASNets' 100% and 92% respectively, GABAR achieves superior plan lengths of 76 and 125 compared to ASNets 79 and 156. This demonstrates that when solving the same problem set, GABAR produces more efficient plans than the baselines.
The combined results further reinforce this analysis. GABAR's average plan lengths of 76, 108, and 147 represent solutions to 95.5%, 92.2%, and 89.2% of all problems respectively. In contrast, competitors with seemingly better plan lengths like GPL (69, 148, 265) only solve 79.1%, 28.5%,
15

---

and 6.5% of problems. The dramatic coverage drop difficulty increases explains why baselines maintain apparently stable plan lengths -hen increasingly solve only the simplest instances while GABAR continues to tackle the complete problem set, including the most complex cases that naturally require longer plans.
This selection bias is precisely why PQR provides a more meaningful comparison. By evaluating plan quality only on problems that both the learned policy and Fast Downward successfully solve, PQR eliminates the confounding factor of different methods tackling different problem subsets. Even when the baselines achieve lower average plan lengths across their limited coverage, their PQR values remain inferior to GABAR's, s, confirming that GABAR's comprehensive coverage does not compromise solution quality when compared fairly on equivalent problem sets.
Table Comparative performance of GABAR against baseline methods (GPL, ASNets, GRAPL). Metrics include Coverage (Cf), Plan Quality Ratio (P"), and absolute Plan Length (PL.). Turqoise color intensity for C values indicates coverage score (Only values above 50% are highlighted). values are highlighted in violet with similar thresholds. Combined rows show averages across all
domains. (*) only non zero values from their respective domains were considered.
GPL
ASNets
GRAPL
GABAR
Domain
Diff
CM
PL4
Ct
Pt
PLJ
Ct
Pf
PLJ
C1
Pt
PL
100
55
100
1.6
0.65
79
100
1.5
Blocks
M
45
0.68
137
100
1.5
79
48
0.44
214
100
1.6
76
10
0.33
423
92
1.4
156
38
0.28
585
100
1.7
125
E
97
0.97
167
100
1.0
162
68
0.56
252
100
1.0
160
Miconic
0.56
235
100
0.98
180
0.54
280
100
0.97
H
19
0.29
448
90
0.92
209
60
0.49
329
100
0.95
202
73
1.1
27
78
0.86
36
22
0.65
35
94
1.1
31
Spanner
M
42
0.56
61
60
0.69
55
0.55
50
93
0.99
0.18
208
42
0.61
89
0.91
67
100
82
78
0.98
0.95
61
100
1.1
Gripper
M
56
0.85
128
54
0.91
118
12
0.67
128
100
0.99
133
0.74
139
42
0.88
131
100
0.96
156
69
1.3
79
94
0.96
121
92
1.1
106
93
1.1
103
Visitall
15
0.76
188
86
0.93
194
181
1.0
179
H
64
0.81
333
78
0.99
272
88
1.1
243
E
74
0.89
41
52
0.81
47
20
0.38
77
100
0.91
45
Grid
M
17
0.61
66
45
0.66
0.28
143
97
0.85
21
0.60
101
92
0.74
98
56
0.61
117
39
0.71
0.81
88
90
0.75
Logistics
M
7
0.21
305
22
0.55
138
9
0.45
169
76
0.65
159
0.39
217
0.59
232
64
0.99
17
67
0.96
19
0.35
44
87
1.0
Rovers
M
0.32
78
56
0.87
36
0.19
125
82
0.96
33
31
0.64
55
77
0.97
45
79.1
0.98
69
76.0
0.98
73
43.5
0.67
91
95.5
1.04
76
Combined
28.5
0.56
148
65.4
0.88
111
29.3
0.51
172
92.2
1.01
108
H
6.5
0.39*
265
48.5
0.78
158
22.1
0.58*
276
89.2
0.99
147
A.5 Beam Search Action Decoder
The beam search action decoder (Algorithm 2 enhances the basic greedy decoder by maintaining multiple candidate sequences at each decoding step.
16

---

Initialization (line 1): Similar to the greedy approach, the decoder initializes its hidden state using the global graph embedding and zero vector.
Action Schema Selection (lines 2-5): Instead of selecting only the highest-scoring action schema, beam search maintains the top-k action schemas. For each action schema A, score Sa is computed (line 3), The & highest-scoring actions form the initial beam Bo (lines 4-5), each representing partial sequence with an action schema, an empty parameter list, the initial hidden state, and the action score.
Parameter Selection with Beam Search (lines 6-15): During each decoding step. the algorithm expands all sequences in the current beam by considering the top-k object candidates for the next parameter position:
For each sequence in the current beam B,-1 (line 9), scores are computed for all objects using the current hidden state (line 10).
The top-k objects O are identified (line 11).
Each sequence is expanded with each of these top-k objects (lines 12-14), creating k x |B,- new candidate sequences in B,
The hidden state is updated for each new sequence (line 13).
The beam is pruned to keep only the highest-scoring expanded sequences (line 15), forming the new beam Br.
Output (line 16): After processing all parameter positions, the algorithm returns the set of completed sequences, each forming a fully grounded action.
In our implementation, we set k: 2 for the beam search. This parameter choice provides reasonable trade-off between exploration and computational efficiency. A beam width of allows the decoder to maintain alternative sequences when faced with uncertainty, which is particularly important for handling invalid actions that might need to be discarded. Setting a larger beam width provides better results thcoretically but increases computational cost without proportional benefits in our domains.
Procedure ACTIONDECODDRIEAMM (ve)ivv A,O,k)
hg GRU(g",
2: // Step 1: Action schema selection
3: Sa MLP(ho v.d,, Va A
4: A" = {a1, a2,.... ax} = top-
5: Bu {(aj, 11, ho, Sa ,a Ma, E A*}
6: // Step 2: Parameter selection with beam search
7: for 1 to max_params do =
9: for (a, [o1,..., 0-1,) E B do
10: MLP(h,, 3 vo), Vo 0
11: O' (or, .2..,,........................ 0k} top-k(so) oEO
12: for 0₂ E O do
13:
h GRU(M--1 v
14:
By = B f(a, (01, O 00-1,
s + so
15:
B top-k(score(b)) BEB:
16: return ((a, 02 02,...
(0.,0, onl)) (0,, o2,.0,, on], N, 8) E Bmaxxpuraass params) }
Algorithm 2: Beam Search Action Decoder
17

---

NeurIPS Paper Checklist
1. Claims
Question: Do the main claims made in the abstract and introduction accurately reflect the paper's contributions and scope?
Answer: [Yes]
Justification: The paper claims that action ranking for planning using an action centric graph representation is better than value function learning. We show that through our results and ablations in table
Guidelines:
The answer NA means that the abstract and introduction do not include the claims made the paper.
The abstract and/or introduction should clearly state the claims made, including the contributions made in the paper and important assumptions and limitations. A No
NA answer to this question will not be perceived well by the reviewers.
The claims made should match theoretical and experimental results, and reflect how much the results can be expected to generalize to other settings.
is fine to include aspirational goals as motivation as long as is clear that these goals not attained by the paper.
2. Limitations
Question: Does the paper discuss the limitations of the work performed by the authors?
Answer: [Yes]
Justification:
The limitations are discussed at the end conclusion section.
Guidelines:
The answer NA means that the paper has limitation while the answer No means that the paper has limitations, but those are not discussed in the paper.
The authors are encouraged to create a separate "Limitations" section in their paper.
The paper should point out any strong assumptions and how robust the results are to violations of these assumptions (c.g.. independence assumptions, noiseless settings, model sell-specfiiatiinn asymptotic approximations only holding locally). ). The authors should reflect on how these assumptions might be violated in practice and what the implications would be.
The authors should reflect the scope of the claims made, e.g., if the approach was only tested on few datasets or with few runs. In general, empirical results often depend on implicit assumptions, which should be articulated.
The authors should reflect on the factors that influence the performance of the approach. For example, facial recognition algorithm may perform poorly when image resolution low or images are taken in low lighting. Or speech-to-tex, system might not be used reliably to provide closed captions for online lectures because it fails handle technical jargon.
The authors should discuss the computational efficiency of the proposed algorithms and how they scale with dataset size.
If applicable, the authors should discuss possible limitations of their approach to address problems of privacy and faimesss.
While the authors might fear that complete honesty about limitations might be used by reviewers as grounds for rejection, a worse outcome might be that reviewers discover limitations that aren't 't acknowledged in the paper. The authors should use their best judgment and recognize that individual actions in favor of transparency play an impor- tant role in developing norms that preserve the integrity of the community, Reviewers will be specifically instructed to not penalize honesty concerning limitations.
3. Theory assumptions and proofs
Question: For each theoretical result, does the paper provide the full set of assumptions and complete (and correct) proof?
18

---

Answer:
[NA]
Justification:
The paper does not contain theoretical results
Guidelines:
The answer NA means that the paper does not include theoretical results.
All the theorems, formulas, and proofs in the paper should be numbered and cross- referenced.
All assumptions should be clearly stated or referenced in the statement of any theorems.
The proof's can either appear in the main paper or the supplemental material, but if they appear in the supplemental material, the authors are encouraged to provide a short proof sketch provide intuition.
Inversely, any informal proof provided in the core of the paper should be complemented by formal proofs provided in appendix or supplemental material.
Theorems and Lemmas that the proof relies upon should be properly referenced.
4. Experimental result reproducibility
Does the paper fully disclose all the information needed to reproduce the main ex- perimental results the paper to the extent that affects the main claims and/or conclusions of the paper (regardless of whether the code and data are provided not)?
Question:
Answer: [Yes]
Justification: We provide graph construction details in section 3.2 and our model running description in Algorithm
Guidelines:
The answer NA means that the paper does not include experiments.
If the paper includes experiments, a No answer to this question will not be perceived well by the reviewers: Making the paper reproducible is important, regardless of whether the code and data are provided or not.
If the contribution is dataset and/or model, the authors should describe the steps taken to make their results reproducible or verifiable.
Depending on the contribution, reproducibility can be accomplished in various ways. For example, if the contribution is a novel architecture, descríbing the architecture fully might suffice, or if the contribution is specific model and empirical evaluation, it may be necessary to either make possible for others to replicate the model with the same dataset, provide access to the model. In general. releasing code and data is often one good way to accomplish this, but reproducibility can also be provided via detailed instructions for how to replicate the results, access to a hosted model (e.g.. g., in the case of a large language model), releasing of a model checkpoint, or other means that are appropriate to the research performed.
While NeurIPS does not require releasing code, the conference does require submis- sions to provide some reasonable avenue for reproducibility, which may depend on the nature of the contribution. For example
(a) the contribution is primarily a new algorithm, the paper should make clear how reproduce that algorithm. (b) If the contribution is primarily new model architecture, the paper should describe the architecture clearly and fully.
(c) the contribution is a new model (e-g., a large language model), then there should either be way to access this model for reproducing the results or way to reproduce the model (e.g., with an open-source dataset or instructions for how to construct the dataset).
(d) We recognize that reproducibility may be tricky in some cases, in which case authors are welcome describe the particular way they provide for reproducibility. In the case of closed-source models, it may be that access to the model is limited in some way (e.g., to registered users), but it should possible for other researchers to have some path to reproducing verifying the results.
5. Open access to data and code
19

---

reproducible, they Does the paper provide open access to the data and code, with sufficient instruc- tions faithfully reproduce the main experimental results, as described in supplemental material?
Question:
Answer: [Yes]
Justification:
Link to code provided in appendix. Data submitted in supplementary material.
Guidelines:
The answer NA means that paper does not include experiments requiring code.
Please see the NeurlPS code and data submission guidelines (https://nips..
sabbic//guieee/oodetttisssssssss
for more details.
While we encourage the release of code and data, we understand that this might not be possible, "No" is acceptable answer. Papers cannot be rejected simply for not including code, unless this is central to the contribution (e.g., for new open-source benchmark).
The instructions should contain the exact command and environment needed to run to reproduce the results. See the NeurIPS code and data submission guidelines (https for more details.
/nips
The authors should provide instructions on data access and preparation, including how access the raw data, preprocessed data, intermediate data, and generated data, etc.
The authors should provide scripts to reproduce all experimental results for the new proposed method and baselines. If only subset of experiments should state which ones are omitted from the script and why.
At submission time, to preserve anonymity, the authors should release anonymized versions (if applicable).
Providing as much information as possible in supplemental material (appended to the paper) recommended, but including URLs to data and code is permitted.
6. Experimental setting/details
Question: Does the paper specify all the training and test details (e.g., data splits, hyper- parameters, how they were chosen, type of optimizer, etc.) necessary to understand the results?
Answer: [Yes]
Justification: Information provided in Section 3.4, training procedure.
Guidelines:
The answer NA means that the paper does not include experiments.
The experimental setting should be presented in the core of the paper to level of detail that is necessary to appreciate the results and make sense of them.
The full details can be provided either with the code, in appendix, as supplemental material.
7. Experiment statistical significance
Question: Does the paper report error bars suitably and correctly defined or other appropriate information about the statistical significance of the experiments?
Answer: [No]
Justification: We present 48 results per method, and have results for a total of methods (7 in main paper and more in appendix), resulting in total of 432 results. Hence, providing еrror bars for all would be highly space consuming. We ensure statistical significance by running our system on large number of problems for each setting. Number of scenes described in experiments section.
Guidelines:
The answer NA means that the paper does not include experiments.
The authors should answer "Yes" if the results are accompanied by emor bars, confi- dence intervals, or statistical significance tests, least for the experiments that support the main claims of the paper.
20

---

The factors of variability that the error bars are capturing should be clearly stated (for example, train/test split, initialization, random drawing of some parameter, or overall run with given experimental conditions).
The method for calculating the error bars should be explained (closed form formula, call to a library function, bootstrap, etc.)
The assumptions made should be given (e.g.. Normally distributed errors).
It should be clear whether the error bar is the standard deviation the standard error of the mean.
It is OK to report 1-sigma error bars, but one should state it. The authors should preferably report a 2-sigma error bar than state that they have 96% CI, if the hypothesis of Normality of errors is not verified.
For asymmetric distributions, the authors should be careful not show in tables figures symmetric error bars that would yield results that are out range (e.g. negative error rates).
If error bars are reported in tables or plots, The authors should explain the text how they were calculated and reference the corresponding figures or tables in the text.
8. Experiments compute resources
For each experiment, does the paper provide sufficient information on the com- puter resources (type of compute workers, memory, time of execution) needed reproduce the experiments?
Question:
Answer: [Yes]
Justification:
Information provided in Section 3.4, training procedure.
Guidelines:
The answer NA means that the paper does not include experiments.
The paper should indicate the type of compute workers CPU or GPU, internal cluster, or cloud provider, including relevant memory and storage.
The paper should provide the amount compute required for each of the individual experimental runs as well estimate the total compute.
The paper should disclose whether the full research project required more compute than the experiments reported in the paper (e.g., preliminary or failed experiments that didn't make into the paper).
9. Code ethics
Question: Does the research conducted the paper conform, in every respect, with the NeurlPS Code of Ethics http://///earrrie..../oo/////eea cc/p
Answer: [Yes]
Justification: There were no human subjects involved in this research and it uses only open source data.
Guidelines:
The answer NA means that the authors have reviewed the NeurIPS Code of Ethics.
the authors answer No, they should explain the special circumstances that require deviation from the Code of Ethics.
The authors should make sure to preserve anonymity (c.g.. if there special consid- eration due to laws or regulations in their jurisdiction..
10. Broader impacts
Question: Does the paper discuss both potential positive societal impacts and negative societal impacts of the work performed?
Answer: [NA]
Justification: There is societal impact of the work performed.
Guidelines:
The answer NA means that there is no societal impact of the work performed.
21

---

If the authors answer NA or No, they should explain why their work has no societal impact or why the paper does not address societal impact.
Examples of negative societal impacts include potential malicious or unintended uses (e.g., disinformation, generating fake profiles, surveillance), fairness considerations (e.g., deployment of technologies that could make decisions that unfairly impact specific groups), privacy considerations, and security considerations.
The conference expects that many papers will be foundational research and not tied to particular applications, let alone deployments. However, if there is direct path to any negative applications, the authors should point it out. For example, it is legitimate to point out that improvement in the quality of generative models could be used to generate deepfakes for disinformation. On the other hand, it is not needed to point out that generic algorithm for optimizing neural networks could enable people to train models that generate Deepfakes faster.
The authors should consider possible harms that could arise when the technology is being used as intended and functioning correctly, harms that could arise when the technology is being used as intended but gives incorrect results, and harms following from (intentional or unintentional) misuse of the technology.
If there are negative societal impacts, the authors could also discuss possible mitigation strategies (e.g., gated release of models, providing defenses in addition attacks, mechanisms for monitoring misuse, mechanisms to monitor how system learns from feedback over time, improving the efficiency and accessibility of ML).
11. Safeguards
Does the paper describe safeguards that have been put in place for responsible release of data models that have high risk for misuse (e.g., pretrained language models, image generators, or scraped datasets)?
Question:
Answer: [NA]
Justification:
The paper poses no such risks.
Guidelines:
The answer NA means that the paper poses no such risks.
Released models that have high risk for misuse or dual-use should be released with necessary safeguards to allow for controlled use of the model, for example by requiring that users adhere to usage guidelines or restrictions to access the model or implementing safety filters.
Datasets that have been scraped from the Internet could pose safety risks. The authors should describe how they avoided releasing unsafe images.
We recognize that providing effective safeguards challenging, and many papers do not require this, but we encourage authors to take this into account and make best faith effort.
12. Licenses for existing assets
Are the creators or original owners of assets (e.g.. code, data, models), used in the paper, properly credited and the license and terms of use explicitly mentioned and properly respected?
Question:
Answer: [Yes]
Justification:
We cite the sources used to generate our data in the appendix.
Guidelines:
The answer NA means that the paper does not use existing assets.
The authors should cite the original paper that produced the code package dataset.
The authors should state which version of the asset used and, possible, include URL
The name of the license (e.g., CC-BY 4.0) should be included for each asset.
For scraped data from a particular source (e.g., website), the copyright and terms of service of that source should be provided.
22

---

If assets are released, the license, copyright information, and terms of use in the thcode. has curated licenses for some datasets. Their licensing guide can help determine the license of dataset.
package should be provided. For popular datasets, batasets.papersstt paperswi
For existing datasets that are re-packaged, both the original license and the license of the derived asset (if it has changed) should be provided.
If this information is not available online, the authors encouraged to reach out the asset's s creators.
13. New assets
Question: Are assets introduced in the paper well documented and is the documentation provided alongside the assets?
Answer: [Yes]
Justification: Our code is linked in the appendix and the test dataset is generated using open source code.
Guidelines:
The answer NA means that the paper does not release new assets.
Researchers should communicate the details of the dataset/code/model as part of their submissions via structured templates. This includes details about training, license, limitations, etc.
The paper should discuss whether and how consent was obtained from people whose asset is used.
At submission time, remember to anonymize your assets (if applicable). You can either create an anonymized URL or include an anonymized zip file.
14. Crowdsoureing and research with human subjects
Question: For crowdsourcing experiments and research with human subjects, does the paper include the full text of instructions given to participants and screenshots, if applicable, as well details about compensation (if any)?
Answer: [NA]
Justification:
The work does not involve crowdsourcing nor research with human subjects
Guidelines:
The answer NA means that the paper does not involve crowdsourcing nor research with human subjects.
Including this information in the supplemental material is fine, but if the main contribu- tion of the paper involves human subjects, then much detail as possible should be included the main paper.
According to the NeurlPS Code of Ethics, workers involved in data collection, curation, other labor should be paid at least the minimum wage in the country of the data collector.
15. Institutional review board (IRB) approvals or equivalent for research with human subjects
Question: Does the paper describe potential risks incurred by study participants, whether such risks were disclosed to the subjects, and whether Institutional Review Board (IRB) approvals (or an equivalent approval/review based on the requirements of your country or institution) were obtained?
Answer: [NA]
Justification:
The work does not involve crowdsourcing nor research with human subjects
Guidelines:
The answer NA means that the paper does involve crowdsourcing nor research with human subjects.
Depending the country in which research is conducted, IRB approval (or equivalent) may be required for any human subjects research. If you obtained IRB approval, you should clearly state this in the paper.
23

---

We recognize that the procedures for this may vary significantly between institutions and locations, and we expect authors adhere the NeurIPS Code of Ethics and the guidelines for their institution.
For initial submissions, do not include any information that would break anonymity (if applicable), such as the institution conducting the review.
16. Declaration of LLM usage
Does the paper describe the usage of LLMs if it is an important, original, or non-standard component of the core methods in this research? Note that if the LLM is used only for writing, editing, formatting purposes and does not impact the core methodology, scientific rigorousness, or originality of the research, declaration is not required.
Question:
Answer: [NA]
Justification: The core method development in this research does involve LLMs as any important, original, or non-standard components.
Guidelines:
The answer NA means that the core method development in this research does not involve LLMs as any important, original, non-standard components.
Please refer to our LLM for what should or should not be described.
24


Reviews:
[{"review_id": "sazzbK4oJs", "reviewer": "Reviewer_zjGm", "summary": "This paper proposes GABAR, a GNN-GRU architecture that ranks executable actions instead of learning value functions or state heuristics. It builds Action-centric graph representation to model relationships between objects, predicates, and actions (unlike prior GNN planners), and Conditional GRU decoder to autoregressively generate grounded actions (schema + parameters). It aims to handle generalization to larger problems (e.g., solves instances larger than training data). It empirically exhibits that the proposed approach outperforms value-based (GPL) and action-ranking (GRAPL) baselines and is more sample-efficient than value-based methods.", "questions": "Please refer to Limitations shown below.", "limitations": "As mentioned in the paper, value functions (GPL) struggle with global consistency in large state spaces, and state-ranking heuristics (GRAPL) require expensive search during execution. Action-ranking methods lack explicit action-object relationships in representations. This paper provides a solution with Action-centric graphs + local ranking to address these gaps, which is interesting. \nHowever, some concerns are as shown below:\nThe graph representation scales with action/predicate arity. High-arity domains (e.g., Logistics with 5+ parameter actions) cause memory/compute bottlenecks.\n\nWhile critical for long-range dependencies (Table 4), global aggregation over all nodes/edges becomes costly for massive graphs (>1k objects).\n\nIt is possible that there are irrelevant actions (e.g., inapplicable in current state) in the planning procedure, which can be pruned. Keeping those actions, as done in the paper, could be a waste of computation.\n\nThe beam width k=2 looks chosen arbitrarily without any justification. Larger k might improve results but is dismissed without ablation. Sequential parameter selection (for each action) could slow planning in real-time systems.\n\nGPL (2022) and ASNets (2020) are not state-of-the-art. Newer relational planners (e.g., diffusion-based/LLM-guided methods) can be considered as baselines. GRAPL (2021) is called \"conceptually similar\", but the proposed approach is compared to an older version.\n\nThe evaluation uses suboptimal Fast Downward (FD-lama) plans as baseline. FD-lama’s satisficing nature inflates PQR (e.g., PQR=1.7 in BlocksWorld implies GABAR is worse than the baseline).\n\nClaims of \"high-quality plans\" are unverified since optimal planners were excluded for runtime reasons.\n\nModels were trained on small, optimally solved instances. Are larger problems simply “copy” small instances? It would be more interesting if some analysis on the relationship between small and larger instances is provided.", "rating": 4, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 2, "clarity": 3, "significance": 2, "originality": 3, "strengths_and_weaknesses": "Novel action-centric graph design and GRU decoder offer promising direction for relational planning. Local action ranking is empirically more scalable than value functions.\n\nScalability claims are not convincing. The evaluation is not conducted on very large graphs (>1k objects) and high-arity domains.\nEvaluation cherry-picks baselines and metrics. It omits SOTA comparisons, using weak PQR baseline.", "was_revised": true, "final_justification": "After the rebuttal, most of my concerns were addressed. Even though I still have concerns about the baselines, I am willing to raise the score to baseline accept.", "rebuttal": "> It is possible that there are irrelevant actions (e.g., inapplicable in current state) in the planning procedure, which can be pruned. \n\n[A]: Our current graph representation only adds information about grounded actions that are applicable in the current state into the graph. We will mention this in the paper. Thank you for pointing it out. \n\n> The beam width k=2 looks chosen arbitrarily without any justification. Larger k might improve results but is dismissed without ablation. Sequential parameter selection (for each action) could slow planning in real-time systems.\n\n[A]: Here are the results for different values of k  (k=1,2,3). As we can see, when we use fully greedy policy (k=1), our accuracy drops, especially in harder domains and hence having a value of k>1 is important. We can also see that having k=3 does not help much in the majority of the domains and it is computationally more expensive. This is why we choose k=2. \n\n\n| Domain | Diff | GABAR-k=1 |  | GABAR-k=2 |  | GABAR-k=3 |  |\n|--------|------|-----------|--|-----------|--|-----------|--|\n|        |      | C↑ | P↑ | C↑ | P↑ | C↑ | P↑ |\n| Blocks | E | 98 | 1.47 | **100** | 1.5 | **100** | **1.51** |\n|        | M | 92 | 1.42 | **100** | 1.6 | **100** | **1.62** |\n|        | H | 65 | 1.0 | **100** | 1.7 | **100** | **1.72** |\n| Miconic | E | 98 | 0.98 | **100** | 1.0 | **100** | **1.01** |\n|         | M | 95 | 0.93 | **100** | 0.97 | **100** | **0.99** |\n|         | H | 72 | 0.75 | **100** | 0.95 | **100** | **0.97** |\n| Spanner | E | 92 | 1.08 | 94 | 1.1 | **95** | **1.11** |\n|         | M | 87 | 0.94 | 93 | 0.99 | **95** | **1.01** |\n|         | H | 62 | 0.69 | 89 | 0.91 | **91** | **0.93** |\n| Gripper | E | 98 | 1.08 | **100** | 1.1 | **100** | **1.11** |\n|         | M | 94 | 0.94 | **100** | 0.99 | **100** | **1.01** |\n|         | H | 71 | 0.78 | **100** | 0.96 | **100** | **0.98** |\n| Visitall | E | 91 | 1.08 | 93 | 1.1 | **94** | **1.11** |\n|          | M | 86 | 0.96 | 91 | 1.0 | **93** | **1.02** |\n|          | H | 68 | 0.92 | 88 | 1.1 | **90** | **1.12** |\n| Grid | E | 98 | 0.89 | **100** | 0.91 | **100** | **0.92** |\n|      | M | 91 | 0.81 | 97 | 0.85 | **99** | **0.87** |\n|      | H | 68 | 0.58 | 92 | 0.74 | **94** | **0.76** |\n| Logistics | E | 87 | 0.73 | 90 | 0.75 | **91** | **0.76** |\n|           | M | 70 | 0.60 | 76 | 0.65 | **78** | **0.67** |\n|           | H | 48 | 0.42 | 71 | 0.59 | **73** | **0.61** |\n| Rovers | E | 85 | 0.98 | 87 | 1.0 | **88** | **1.01** |\n|        | M | 76 | 0.91 | 82 | 0.96 | **84** | **0.98** |\n|        | H | 56 | 0.78 | 77 | 0.97 | **79** | **0.99** |\n| **Combined** | E | 93.2 | 0.98 | 95.5 | 1.0 | **96.0** | **1.01** |\n|              | M | 86.4 | 0.93 | 92.2 | 1.0 | **93.2** | **1.02** |\n|              | H | 63.8 | 0.76 | 89.2 | 0.99 | **90.4** | **1.01** |\n\nGABAR-k=1 shows poorer performance (especially in hard - drop from 89.2 to 63.8) because it employs a greedy approach and hence cannot do cycle avoidance. \nGABAR-k=3 demonstrates consistent improvements over k=2, particularly evident in the combined results where it achieves the best coverage and plan quality across all difficulty levels. However, these improvements are modest - typically 1-2 percentage points for coverage and 0.01-0.02 for plan quality ratio.\nGABAR-k=2 represents the optimal balance point. While k=3 shows slight performance gains, the computational cost increases significantly with higher k values due to the growth time taken for beam search. The marginal improvements offered by k=3 do not justify the additional computational expense, making k=2 the practical choice for the GABAR algorithm. (It takes about 30% longer to rank actions for any given state).\n\n\n>GPL (2022) and ASNets (2020) are not state-of-the-art. Newer relational planners (e.g., diffusion-based/LLM-guided methods) can be considered as baselines. GRAPL (2021) is called \"conceptually similar\", but the proposed approach is compared to an older version.\n\n[A]: \n One of the LLM based works that solves very similar problems is the paper named “ Generalized Planning in PDDL Domains with Pretrained Large Language Models”. In this work, they solve 2 of the same domains as we do -> Miconic and grippers. The best results for their LLM approach for these domains are as follows : For the “Gripper” domain, they solve problems upto size of 80 objects and have a best success rate of 90% . In our work, we solve problems upto size 100 and have a success rate of 100%. In the “Miconic” domain, they solve problems of size 11-150 but have a best success rate of 1% when random itself has a success rate of 13%. In our work, we solve “Miconic” problems of up to a size of 100 but have a 100% success rate. (All their results reported are from table 1 in [1]). \n\nWhile LLMs show promise for planning tasks, these results demonstrate that our method provides the reliability and consistency required for generalized planning problems. The stark performance differences, particularly in Miconic where LLMs perform significantly worse than random, highlight the current limitations of LLM-based approaches for structured planning problems.\n\nWe are also currently trying to get an LLM baseline running but it might not be ready in time before the end of the rebuttal period. We can definitely add it in the final version of the paper. \n\nCould you also please clarify what you mean by what you mean by \" GRAPL (2021) is called \"conceptually similar\",the proposed approach is compared to an older version.\" We compare our work to \"Learning generalized relational heuristic networks for model-agnostic planning (which we call GRAPL)\" from their 2021 paper. \n\n>The evaluation uses suboptimal Fast Downward (FD-lama) plans as baseline. FD-lama’s satisficing nature inflates PQR (e.g., PQR=1.7 in BlocksWorld implies GABAR is worse than the baseline).\n\n[A]: Since optimal planning is intractable, we had to rely on suboptimal planners for comparison. Higher PQR means the produced plan length was smaller (and hence, better) by a particular method - PQR =(plan length by FD-Lama/Plan length by method). Hence, higher PQR of 1.7 in blocksworld implies that GABAR is better than other methods (AsNets with 1.4, GPL with 0.33 and GRAPL with 0.28 in Blocksworld Hard) as higher PQR means the plan output by GABAR was the shorter than methods with lower PQR. A PQR greater than 1 implies GABAR’s plans were shorter than FD-LAMA plans. The same trend of GABAR being better (higher PQR) is true for all domains hard dataset,  and even when ASNEts is better than GABAR in some domain’s easy dataset, it is by a very small margin (1.6 for ASNets v/s 1.5 for GABAR in blocksworld easy and 0.98 v/s 0.97 in gripper medium).\n\n>Claims of \"high-quality plans\" are unverified since optimal planners were excluded for runtime reasons.\n\n[A]: While we do not have optimal plans for baselines, our claim of higher quality plans is still valid from a relative stand point. The lengths of the plans produced by our system are on average shorter than the baselines as well as the ablations. While this does not guarantee that the produced plan is optimal, it does imply that our method does indeed produce higher-quality plans compared to the baselines and ablations.\n\n> Models were trained on small, optimally solved instances. Are larger problems simply “copy” small instances? It would be more interesting if some analysis on the relationship between small and larger instances is provided.\n\n[A]: \n[I] : Independent Problem Generation: All problem instances are generated using PDDL generators that employ parameterized templates with randomized elements including initial states, goal configurations, and object placements. This process ensures that each instance is structurally unique rather than a scaled version of existing problems. The generators vary key structural parameters to create distinct planning challenges at scale.\n\nThe  PDDL-generators for each domain follow high level structure which is as follows: \nRandom Initial Placement: Entities start in random valid positions to create diverse problem instances\nConstraint-Aware Generation: Placement respects domain rules (e.g., conflicting entities can't share locations)\nNon-Trivial Goal Creation: Goals are designed to require actual planning steps, not just immediate solutions\nSolvability Assurance: Generation logic ensures created problems have valid solutions\n\n[ii] : Empirical Evidence of Increased Complexity: We have other forms of evidence demonstrating that larger instances represent fundamentally harder problems rather than trivial extensions:\n\n[i] : Plan Length Analysis: The plan lengths for problems in the hard domain are consistently higher than those in the easy domain when solved by satisficing planners, indicating increased solution complexity.\n\n[ii] : Planner Performance Differential: Optimal planners successfully solve multiple problems in the easy domain but fail to solve any problems in the hard domain within reasonable time limits. This performance gap reflects genuine computational complexity differences rather than simple scaling effects.\n\n> Scalability claims are not convincing. The evaluation is not conducted on very large graphs (>1k objects) and high-arity domains. Evaluation cherry-picks baselines and metrics. \n\n[A]  We have provided results for 2 other metrics -> Plan length (PL) as response to reviewer \"CZcC\" , Wall Clock Time (WC) as a response to  \"hZMb\". For scalability, even state of the art learning methods that use search [1], do not solve problems with more than 1k objects (Table 1). Also, their systems are given 30 minutes to run since they use search whereas we use less than 2 minutes to find solutions as we do not use search. That is also why we compare to methods that do not use search. \n\n[1] Hao, Mingyu, et al. \"Guiding GBFS through learned pairwise rankings.\"  {IJCAI-24}."}, {"review_id": "j68lezmT5m", "reviewer": "Reviewer_CZcC", "summary": "The work proposes a method to rank actions using GNNs for generalized planning.\n\nThis work follows the generalized planning paradigm where policies are learned for small problems and work successfully for larger problem, leading to scalable planning.  The novel  contribution is that it proposes to use graph neural networks to learn to rank actions. Experimental comparison with three generalized planning algorithms show that GABAR strongly outperforms them in Grid, Logistics and Rovers domains, for the easy problems. For the medium and hard problems the performance of GABAR is significantly better than others for the most of the domains.", "questions": "1. How do you think this work will perform compared to using large language models to learn the generalized policies? \n2. In the experiments, the work achieve good results in out of distribution testing. I observe that the problem sizes are higher in medium and hard cases. However, there are other variables in the initial states and goals of the problem instances, for example, graph connectivity in the grid world domains. Was that measured in any way?\n3. In the Coverage metric, there is a hard cutoff of 1000 steps, and the measured value is 0/1. Do you have any results on the distribution of number steps taken to find the plan?", "limitations": "Yes", "rating": 5, "confidence": 3, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 2, "clarity": 2, "significance": 3, "originality": 3, "strengths_and_weaknesses": "I found the abstract and introduction quite hard to follow. It took me several rereads to understand the contribution. The writing can be improved I think for the introduction and methodology sections. \n\nThe premise is that ranking actions is easier than calculating the value function accurately, which is well established in literature. The action ranking however should be goal dependent. Before going into the details of the GNN based procedure, I would suggest to define the problem of ranking actions, and how the plan is derived or executed using the ranking.\n\nIn the experiments, the work achieve good results in out of distribution testing. I observe that the problem sizes are higher in medium and hard cases. However, there are other variables in the initial states and goals of the problem instances, for example, graph connectivity in the grid world domains. Was that measured in any way? Showing the rouge scores may be useful. \n\nHow do you think this work will perform compared to using large language models to learn the generalized policies? \n\nFor example, Silver, Tom, Soham Dan, Kavitha Srinivas, Joshua B. Tenenbaum, Leslie Kaelbling, and Michael Katz. \"Generalized planning in pddl domains with pretrained large language models.\" In *Proceedings of the AAAI conference on artificial intelligence*, vol. 38, no. 18, pp. 20256-20264. 2024.\n\nIn the Coverage metric, there is a hard cutoff of 1000 steps, and the measured value is 0/1. Do you have any results on the distribution of number steps taken to find the plan?\n\nMinor: \n\n1. Figure 1 font size is too small.", "was_revised": true, "final_justification": "The authors have clarified the issues I had raised in my review regarding comparison with the generalized policies work, and my questions about the experimental results. I was positive about the paper and I am satisfied with the authors' response and increasing my score to accept as a result.", "rebuttal": ">How do you think this work will perform compared to using large language models to learn the generalized policies? \n\n[A]: We can compare our work to their work (Generalized planning in pddl domains with pretrained large language models) [1] to some extent.. In this work, they solve 2 of the same domains as we do -> Miconic and grippers. The best results for their LLM approach for these domains are as follows : For the “Gripper” domain, they solve problems upto size of 80 objects and have a best success rate of 90% . In our work, we solve problems upto size 100 and have a success rate of 100%. In the “Miconic” domain, they solve problems of size 11-150 but have a best success rate of 1% when random itself has a success rate of 13%. In our work, we solve “Miconic” problems of up to a size of 100 but have a 100% success rate. (All their results reported are from table 1 in [1]). \n\nWhile LLMs show promise for planning tasks, these results demonstrate that our method provides the reliability and consistency required for generalized planning problems. The stark performance differences, particularly in Miconic where LLMs perform significantly worse than random, highlight the current limitations of LLM-based approaches for structured planning problems.\n\nWe are also currently trying to get an LLM baseline running but it might not be ready in time before the end of the rebuttal period. We can definitely add it in the final version of the paper. \n\n>In the experiments, the work achieve good results in out of distribution testing. I observe that the problem sizes are higher in medium and hard cases. However, there are other variables in the initial states and goals of the problem instances, for example, graph connectivity in the grid world domains. Was that measured in any way?\n\n[A]: Graph size increases as we go from easy to hard problems as expected. \nSo we measured the average degree of nodes (AD) in the graph across domains and difficulty levels. What we noticed was that AD remained very similar across all difficulty levels for all domains. What this implies is, is all domains, the number of possible actions an object can be part of similar (even though more actions are applicable since there are more objects). \n\nOther trend we noticed was that the AD was slightly higher for harder domains and lower for easier domains: \n\nEasy domains: \n    spanner : 1.9, blocks : 2.4, gripper 2.65 : , miconic :2.3\n\nharder domains:\n    visitall :  2.93, logistics : 3.15 , grid : 2.8, rovers : 3.1\n\n\n>In the Coverage metric, there is a hard cutoff of 1000 steps, and the measured value is 0/1. Do you have any results on the distribution of number steps taken to find the plan?\n\n[A]:\nWe run our method and the baselines as policies - we input a state and get the next action to take and do not do any search - running the learning method as a policy.  From our understanding, the number of steps taken to find the plan would be equal to the plan length (slightly higher when we have cycles). Please let us know if you were looking for a different metric. \nWe do have the mean plan lengths for each baseline for all domains and difficulty levels. Here  are the plan lengths (PL), lower the better.  \n\n| Domain | Diff | GPL C | GPL P | GPL PL | ASNets C | ASNets P | ASNets PL | GRAPL C | GRAPL P | GRAPL PL | GABAR C | GABAR P | GABAR PL |\n|--------|------|-------|-------|--------|----------|----------|-----------|---------|---------|----------|---------|---------|----------|\n| Blocks | E | 100 | 1.1 | 55 | 100 | 1.6 | **38** | 64 | 0.65 | 79 | **100** | **1.46** | 41 |\n| Blocks | M | 45 | 0.68 | 137 | 100 | 1.5 | 79 | 48 | 0.44 | 214 | **100** | **1.57** | **76** |\n| Blocks | H | 10 | 0.33 | 423 | 92 | 1.4 | 156 | 38 | 0.28 | 585 | **100** | **1.74** | **125** |\n| Miconic | E | 97 | 0.97 | 167 | 100 | 1.0 | 162 | 68 | 0.56 | 252 | **100** | **1.01** | **160** |\n| Miconic | M | 37 | 0.56 | 235 | 100 | 0.98 | **180** | 65 | 0.54 | 280 | **100** | **0.97** | 181 |\n| Miconic | H | 19 | 0.29 | 448 | 90 | 0.92 | 209 | 60 | 0.49 | 329 | **100** | **0.95** | **202** |\n| Spanner | E | 73 | 1.1 | **27** | 78 | 0.86 | 36 | 22 | 0.65 | 35 | **94** | **1.05** | 31 |\n| Spanner | M | 42 | 0.56 | 61 | 60 | 0.69 | 55 | 5 | 0.55 | 50 | **93** | **0.99** | **44** |\n| Spanner | H | 3 | 0.18 | 208 | 42 | 0.61 | 79 | - | - | - | **89** | **0.91** | **67** |\n| Gripper | E | 100 | 1.0 | 82 | 78 | 0.98 | 76 | 26 | 0.95 | **61** | **100** | **1.05** | 78 |\n| Gripper | M | 56 | 0.85 | 128 | 54 | 0.91 | **118** | 12 | 0.67 | 128 | **100** | **0.99** | 133 |\n| Gripper | H | 21 | 0.74 | **139** | 42 | 0.88 | 131 | - | - | - | **100** | **0.96** | 156 |\n| Visitall | E | 69 | 1.3 | **79** | 94 | 0.96 | 121 | 92 | 1.1 | 106 | **93** | **1.13** | 103 |\n| Visitall | M | 15 | 0.76 | 188 | 86 | 0.93 | 194 | 88 | 1.0 | 181 | **91** | **1.01** | **179** |\n| Visitall | H | - | - | - | 64 | 0.81 | 333 | 78 | 0.99 | 272 | **88** | **1.11** | **243** |\n| Grid | E | 74 | 0.89 | **41** | 52 | 0.81 | 47 | 20 | 0.38 | 77 | **100** | **0.91** | 45 |\n| Grid | M | 17 | 0.61 | **66** | 45 | 0.66 | 73 | 3 | 0.28 | 143 | **97** | **0.85** | 63 |\n| Grid | H | - | - | - | 21 | 0.60 | 101 | - | - | - | **92** | **0.74** | **98** |\n| Logistics | E | 56 | 0.61 | 117 | 39 | 0.71 | 101 | 32 | 0.81 | **88** | **90** | **0.75** | 127 |\n| Logistics | M | 7 | 0.21 | 305 | 22 | 0.55 | **138** | 9 | 0.45 | 169 | **76** | **0.65** | 159 |\n| Logistics | H | - | - | - | 4 | 0.39 | **217** | - | - | - | **71** | **0.59** | 232 |\n| Rovers | E | 64 | 0.99 | **17** | 67 | 0.96 | 19 | 21 | 0.35 | 44 | **87** | **1.02** | 21 |\n| Rovers | M | 9 | 0.32 | 78 | 56 | 0.87 | 36 | 5 | 0.19 | 125 | **82** | **0.96** | **33** |\n| Rovers | H | - | - | - | 31 | 0.64 | 55 | - | - | - | **77** | **0.97** | **45** |\n| Combined | E | 79.1 | 0.98 | **69** | 76.0 | 0.98 | 73 | 43.5 | 0.67 | 91 | **95.5** | **1.04** | 76 |\n| Combined | M | 28.5 | 0.56 | 148 | 65.4 | 0.88 | **111** | 29.3 | 0.51 | 172 | **92.2** | **1.01** | 108 |\n| Combined | H | 6.5 | 0.39 | 265 | 48.5 | 0.78 | 158 | 22.1 | 0.58 | 276 | **89.2** | **0.99** | **147** |\n\nLooking at the Plan Length (PL) results, it's important to first recognize that within each difficulty level (Easy, Medium, Hard), there exists a substantial range of problem complexity and sizes. Each dataset contains problems spanning from relatively simple instances to much more challenging ones, even within the same nominal difficulty category. This inherent variability means that methods with lower coverage are naturally biased toward solving the simpler instances within each difficulty level, which fundamentally affects plan length comparisons.\n\nGABAR demonstrates remarkable efficiency when we properly contextualize the coverage differences. While GABAR doesn't always achieve the absolute lowest plan lengths, its performance becomes exceptional when we consider that it consistently solves significantly more problems than its competitors across this entire spectrum of problem complexity.\n\nThe apparent discrepancies in plan length can be largely explained by the coverage differences between methods. When GPL achieves a lower plan length of 27 on Spanner-Easy compared to GABAR's 31, we must note that GPL only covers 73% of the problems while GABAR covers 94%. Similarly, on Visitall-Easy, GPL achieves a plan length of 79 with only 69% coverage, while GABAR produces plans of length 103 but solves 93% of the problems. The additional problems that GABAR solves are likely the more complex instances that require longer plans, explaining the higher average plan length.\n\nWhen examining cases where coverage is comparable, GABAR's plan length performance becomes more impressive. On Blocks-Medium and Hard, where GABAR maintains 100% coverage compared to ASNets' 100% and 92% respectively, GABAR actually achieves the best plan lengths of 76 and 125. This demonstrates that when solving the same problem set, GABAR often produces more efficient plans than its competitors.\n\nThe combined results further reinforce this analysis. GABAR's average plan lengths of 76, 108, and 147 represent solutions to 95.5%, 92.2%, and 89.2% of all problems respectively. In contrast, competitors with seemingly better plan lengths like GPL (69, 111, 147) are only solving 79.1%, 28.5%, and 6.5% of the problems. The dramatic drop in coverage as difficulty increases explains why competitors maintain stable plan lengths - they increasingly solve only the simplest instances while GABAR continues to tackle the complete problem set, including the most complex cases that naturally require longer plans.\nAlso, even when the average plan length is lower, PQR is still worse because PQR is computed only for solved problems and compared to the FD-LAMA method. \n\n[1] Generalized Planning in PDDL Domains with Pretrained Large Language Models. Silver et. al., AAAI 2024."}, {"review_id": "JqAoqBUlGg", "reviewer": "Reviewer_hZMb", "summary": "This paper proposes a graph structure and GNN architecture for action ranking in classical planning. The GNN is trained on small problems and generalized to larger ones. Experiments on benchmark domains compare the proposed method to several baselines and ablations.", "questions": "1. Just to be sure, can you confirm that all of the baselines (GPL, ASNets, and GRAPL) were trained, validated, and tested on the same problem instances?  \n2. Can you also confirm whether the “avoid repeated states” trick was used by the baselines as well? And if not, can you report results indicating how much that trick alone matters?  \n3. Can you report wall-clock timing results?", "limitations": "yes", "rating": 5, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 4, "clarity": 4, "significance": 2, "originality": 2, "strengths_and_weaknesses": "### Strengths\n\n**Results.** The results are strong. These are difficult and well-established benchmarks and the proposed method consistently outperforms baselines and ablations.\n\n**Clarity**. The paper is extremely clear and well written. There are some opportunities to improve the writing style, but I was able to fully understand almost everything without much effort.\n\n**Reproducibility.** I highly commend the authors for providing such thorough code and experimental details in the main text.\n\n**Graph structure.** The graph structure proposed is very intuitive. I am not aware of prior work that uses this exact structure.\n\n### Weaknesses\n\n**Timing results not reported.** Since planners like Fast Downward are complete, what ultimately matters is not just effectiveness (whether tasks are solved) but also efficiency (how much time overall is taken, including planning time). There are no timing results reported in the paper and I think it is quite plausible that Fast Downward with lama-first would perform similar to or better than the proposed approach. Action grounding is often the bottleneck in problems with many objects, and the proposed approach requires action grounding. Relatedly, it seems misleading to say that “planning is computationally prohibitive” for the larger test problems when FD is being run to report the plan quality ratios.\n\n**Limited novelty.** While the reported results are impressive and perhaps enough to justify publication, there is ultimately limited novelty in this work. As the paper notes, the idea to use GNNs for generalized planning has been pursued in a number of previous works. The insight that action ranking can be better than value function learning is also not original to this work, even though that insight is the focus of this paper’s narrative.\n\n**Loss function unclear.** I did not fully understand the loss function described in L209-212. In particular, it is said that GABAR computes scores for all actions. Are these scores 0 for all actions except the correct one? This wasn’t clear. A related point of confusion is why one action is randomly selected in the case where multiple are optimal. Why can’t we just say that multiple are optimal?\n\n**LLM baseline.** This is not a major weakness and it is not absolutely necessary, but I think it would strengthen the paper if an LLM baseline was included, such as the generalized planner from \\[1\\]. Or if there is reason to exclude such baselines, then it would be good to note those reasons in the paper. Especially for a NeurIPS audience, readers are likely to wonder whether the problem setting considered in this paper is “solved” by LLMs.\n\n\\[1\\] Generalized Planning in PDDL Domains with Pretrained Large Language Models. Silver et. al., AAAI 2024\\.", "was_revised": true, "final_justification": "This is overall a solid paper and it will be even stronger with the new LLM baseline results.", "rebuttal": "> LLM baseline discussion:\n\n[A]: We can compare our work to their work to some extent.  In this LLM approach [1], they solve 2 of the same domains as we do -> Miconic and “gripper”. Their best results from the paper for these domains are as follows : For the “Gripper” domain, they solve problems upto size of 80 objects and have a best success rate of 90% . In our work, we solve problems upto size 100 and have a success rate of 100%. In the “Miconic” domain, they solve problems of size 11-150 but have a best success rate of 1% when random itself has a success rate of 13%. In our work, we solve “Miconic” problems of up to a size of 100 but have a 100% success rate. (All their results reported are from table 1 in [1]). \n\nWhile LLMs show promise for planning tasks, these results demonstrate that our method provides the reliability and consistency required for generalized planning problems. The stark performance differences, particularly in Miconic where LLMs perform worse than random, highlight the current limitations of LLM-based approaches for structured planning problems.\n\nWe are also currently trying to get an LLM baseline running but it might not be ready in time before the end of the rebuttal period. We can definitely add it in the final version of the paper. \n\n> Loss function. It is said that GABAR computes scores for all actions. Are these scores 0 for all actions except the correct one? Why one action is randomly selected in the case where multiple are optimal?\n\n[A]: Yes, during training, scores are 0 for all actions except the correct one. \nIn the case when multiple actions are optimal, the action considered optimal is one that was output by a planner- as we use an optimal planner to generate training data on small problems - whatever the planner has output as the action to take at that current state is the one considered as the correct one.( Since the training data consists of only a single optimal plan for each problem as the set of all optimal plans is very time consuming to compute, we only have one correct action)\n\n> Limited Novelty\n\nOur main contribution is the action centric graph structure and the conditional decoder architecture. Our ablation studies show these 2 components play a big part in learning a good action ranking function. \n\n>Can you confirm that all of the baselines were trained, validated, and tested on the same problem instances? \n\n[A]: Yes, all the baselines were trained and tested on the same problem instances. \n\n>Can you also confirm whether the “avoid repeated states” trick was used by the baselines as well? \n\n[A]: Yes, all baselines and ablations also avoid repeated states. \n\n>Can you report wall-clock timing results?\n\n[A]: Here are the wall clock timing results for all baselines and our method - Wall Clock Time (WC) (in seconds). It is the average time taken per solved problem for a given domain. \n\n\n| Domain | Diff | GPL C↑ | GPL P↑ | GPL WC↓ | ASNets C↑ | ASNets P↑ | ASNets WC↓ | GRAPL C↑ | GRAPL P↑ | GRAPL WC↓ | GABAR C↑ | GABAR P↑ | GABAR WC↓ | FD-Lama-first WC↓ |\n|--------|------|-------|-------|--------|-------|-------|--------|-------|-------|--------|-------|-------|--------|-------|\n| Blocks | E | 100 | 1.10 | 1.2 | 100 | 1.60 | 1.5 | 64 | 0.65 | 0.8 | 100 | 1.50 | **0.5** | 0.8 |\n| | M | 45 | 0.68 | 3.8 | 100 | 1.50 | 4.2 | 48 | 0.44 | **1.6** | 100 | 1.60 | 4.8 | 2.1 |\n| | H | 10 | 0.33 | 3.7 | 92 | 1.40 | 5.3 | 38 | 0.28 | **3.2** | 100 | 1.70 | 11.8 | 45.3 |\n| Miconic | E | 97 | 0.97 | 1.8 | **100** | **1.00** | 1.2 | 68 | 0.56 | **1.1** | **100** | **1.00** | 1.2 | 1.4 |\n| | M | 37 | 0.56 | 9.1 | **100** | **0.98** | **4.3** | 65 | 0.54 | 4.9 | **100** | 0.97 | 7.1 | 5.2 |\n| | H | 19 | 0.29 | 15.6 | 90 | 0.92 | 14.5 | 60 | 0.49 | **12.7** | **100** | **0.95** | 19.2 | 34.7 |\n| Spanner | E | 73 | **1.10** | 1.5 | 78 | 0.86 | 0.8 | 22 | 0.65 | 1.2 | **94** | **1.10** | **0.3** | 0.6 |\n| | M | 42 | 0.56 | 2.8 | 60 | 0.69 | 2.4 | 5 | 0.55 | **1.1** | **93** | **0.99** | 2.1 | 3.1 |\n| | H | 3 | 0.18 | 11.3 | 42 | 0.61 | 7.2 | 0 | - | - | **89** | **0.91** | **5.2** | 18.4 |\n| Gripper | E | **100** | 1.00 | 4.2 | 78 | 0.98 | 6.1 | 26 | **0.95** | 4.7 | **100** | **1.10** | **3.1** | 3.8 |\n| | M | 56 | 0.85 | 13.5 | 54 | 0.91 | 21.4 | 12 | 0.67 | **13.3** | **100** | **0.99** | 22.1 | 15.7 |\n| | H | 21 | 0.74 | **41.3** | 42 | 0.88 | 59.2 | 0 | - | - | **100** | **0.96** | 67.8 | 87.9 |\n| Visitall | E | 69 | **1.30** | 18.0 | **94** | 0.96 | 11.0 | 92 | 1.10 | 13.1 | 93 | 1.10 | **6.2** | 7.8 |\n| | M | 15 | 0.76 | 43.0 | 86 | 0.93 | 31.0 | 88 | **1.00** | 47.9 | **91** | **1.00** | 38.7 | 31.5 |\n| | H | 0 | 0.00 | - | 64 | 0.81 | 101.0 | 78 | 0.99 | **92.0** | **88** | **1.10** | 98.1 | 136.2 |\n| Grid | E | 74 | 0.89 | 10.5 | 52 | 0.81 | 3.5 | 20 | 0.38 | 12.0 | **100** | **0.91** | **2.1** | 2.9 |\n| | M | 17 | 0.61 | 19.5 | 45 | 0.60 | 24.5 | 3 | 0.28 | 28.9 | **97** | **0.85** | **14.8** | 16.2 |\n| | H | 0 | 0.00 | - | 21 | 0.60 | 69.0 | 0 | - | - | **92** | **0.74** | **42.1** | 31.8 |\n| Logistic | E | 56 | 0.61 | 6.7 | 39 | 0.71 | 13.5 | 32 | **0.81** | 8.5 | **90** | 0.75 | **3.8** | 4.5 |\n| | M | 7 | 0.21 | 28.5 | 22 | 0.55 | 19.2 | 9 | 0.45 | **17.3** | **76** | **0.65** | 23.1 | 12.8 |\n| | H | 0 | 0.00 | - | 4 | 0.39 | **27.0** | 0 | - | - | **71** | **0.59** | 64.1 | 48.3 |\n| Rovers | E | 64 | **0.99** | 3.0 | 67 | 0.96 | 1.7 | 21 | 0.35 | 2.0 | **87** | **1.00** | **0.7** | 1.2 |\n| | M | 9 | 0.32 | 6.1 | 56 | **0.87** | 6.3 | 5 | 0.19 | **2.0** | **82** | **0.96** | 4.1 | 7.8 |\n| | H | 0 | 0.00 | - | 31 | 0.64 | 13.0 | 0 | - | - | **77** | **0.97** | **10.2** | 28.6 |\n| Combined | E | 79.1 | 0.99 | 5.9 | 76.0 | 0.98 | 4.9 | 43.1 | 0.68 | 5.4 | **95.5** | **1.06** | **2.2** | 2.87 |\n| | M | 28.5 | 0.57 | 15.8 | 65.4 | 0.88 | **14.2** | 29.4 | 0.52 | 14.6 | **92.4** | **1.00** | 14.6 | 11.8 |\n| | H | 6.6 | 0.19 | **18.0** | 48.3 | 0.78 | 37.0 | 22.0 | 0.59 | 36.0 | **89.6** | **0.99** | 39.8 | 53.9 |\n\nWhile GABAR may show higher WC (therefore worse) values in some cases, this must be interpreted alongside its significantly higher coverage rates which outperforms all competing approaches. The apparent timing advantage of other methods stems from solving fewer problems overall. These methods solve easier instances within each difficulty category, creating a selection bias where their WC metrics are computed only over successfully solved problems that tend to be less challenging.\nThis is particularly evident in Hard instances, where competing methods achieve very low coverage (GPL: 0-21%, ASNets: 21-92%, GRAPL: 0-78%) while GABAR maintains 71-100% coverage. The favorable WC values for baselines reflect computation over a smaller, easier subset of problems, making direct comparisons misleading. Each difficulty tier contains problems of varying complexity, and methods with lower coverage systematically avoid more challenging instances that GABAR successfully solves.\nCompared to FD-Lama-first, GABAR shows superiority in Hard instances with lower WC (39.8 vs 53.9). Even in Easy and Medium instances, GABAR achieves competitive WC performance."}, {"review_id": "6GTj79ZSHO", "reviewer": "Reviewer_VXL5", "summary": "The authors propose a a way to featurize grounded PDDL problems and pass them into a GNN-based policy that outputs $k$ ranked action candidates conditioned on current state. To produce a plan, the authors iteratively execute the highest-ranked action until the goal is achieved. Experiments show that this approach scales to hard problem instances in several IPC domains, better than some reasonable baselines.", "questions": "See above", "limitations": "yes", "rating": 5, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 3, "clarity": 4, "significance": 3, "originality": 3, "strengths_and_weaknesses": "Overall, I think this is a good paper. It is not the most groundbreaking idea, but the paper is clearly written, the contribution is clear and focused, and the experiments show a convincing improvement over a set of well-chosen baselines.\n\nMy key reservation is that I am not sure the work is novel. In particular, the following paper also demonstrates a way to featurize PDDL states and feed them through a GNN:\nRivlin, Or, Tamir Hazan, and Erez Karpas. \"Generalized planning with deep reinforcement learning.\" arXiv preprint arXiv:2005.02305 (2020).\nNote that this paper was not published (except, seemingly, at the PRL2020 ICAPS workshop), so I will not hold that against the authors. Nevertheless, I'd encourage the authors to read, cite, and perhaps even compare against that paper.\n\nA medium-level concern I have is that the authors refer continuously to the approach as \"ranking actions\", but really the GNN is just a policy: given a state, output an action. It was not until I reached Section 3.3.2 where I finally understood what the authors meant by ranking: a beam search that returns $k$ different ordered action groundings. I'd suggest to the authors to introduce this concept in the abstract/intro, or maybe just rename their contribution from \"action ranking\" to \"learning a GNN policy\" or \"learning a GNN actor\", since that's really what you are doing here, with a light beam search on top.\n\nQuestions and smaller comments:\n* Regarding the beam search, am I correct in understanding that this is only used during test time, not for training the GNN?\n* L45: typo, \"explicitly\"\n* Figure 1: I think it would be much clearer to say \"State and Goal\" rather than just \"State\" for the left-most figure. The caption does not describe what the \"G\" prefix means.\n* How many training problem instances were used? Sorry if I missed it.\n* L124: Have you tried ablating the global features to verify the claim that they are \"essential in passing information at each round from nodes that are far apart\"?\n* Can you explain GABAR-RANK more? You say in L286 that \"Our ablation GABAR-RANK, which replaces action ranking with value function learning while keeping our graph structure intact\" -- but how can the graph structure stay intact if GABAR's network outputs actions while GABAR-RANK's network outputs values (which are floats)?", "was_revised": true, "final_justification": "I keep my score the same (Accept) after reading the rebuttal.", "rebuttal": ">Regarding the beam search, am I correct in understanding that this is only used during test time, not for training the GNN?\n\n[A]: Yes, beam search is only used during testing\n\n>L45: typo, \"explicitly\"\n\n[A]: We will update it. \n\n>Figure 1: I think it would be much clearer to say \"State and Goal\" rather than just \"State\" for the left-most figure. The caption does not describe what the \"G\" prefix means.\n\n[A]: Thank you for pointing it out. We will update the figure to say both “State and Goal”\n\n>How many training problem instances were used? Sorry if I missed it. \n\n[A]: The number of problem instances is approximately 200 for all domains. The total number of datapoints for training are mentioned in Table 3 of Appendix A.1. (The number of datapoints are different even with the same number of problem instances because each problem instance generates a plan which could be of different lengths. Each action in this plan becomes a datapoint for our learning system). \n\n>L124: Have you tried ablating the global features to verify the claim that they are \"essential in passing information at each round from nodes that are far apart\"? \n\n[A]: Yes, we have done the ablation on global features. The results are provided in Table 4, under GABAR-G (Appendix A.2 contains the analysis). \n\n\n>Can you explain GABAR-RANK more? You say in L286 that \"Our ablation GABAR-RANK, which replaces action ranking with value function learning while keeping our graph structure intact\" -- but how can the graph structure stay intact if GABAR's network outputs actions while GABAR-RANK's network outputs values (which are floats)?\n\n[A]: The graph network outputs a global vector (in figure 1, after the GNN processing, you can see gL -> that is the output of the graph network. This gL is used by a GRU decoder to rank actions. But, in the case of GABAR-RANK, we simply use an MLP on top of this gL to output a single real number, which is the value of a given state. During training, this output is compared to a real value function and we used MSE loss to train the GNN to output good values."}]

Author rebuttal:

Meta-review: A. This work follows the generalized planning paradigm where policies are learned for small problems and work successfully for larger problem. This paper extents prior work by proposing to use a graph neural networks to learn to rank actions, a graph representation that captures action-object relationships, and a decoder to construct grounded actions. Experiments show that this approach scales to hard problem instances in several IPC domains, better than some reasonable baselines.

B. Reviewers appreciated the novelty of the proposed approach and its scalability. They also appreciated the inclusion of code.

C. The main reviewer question was about the scalability of the method and its comparison with LLM-based methods (which was addressed with a new experiment in the rebuttal). Reviewers also had questions about novelty and presentation.

D. Reviewers unanimously voted to accept the paper.

E. Authors ran additional experiments to answer reviewer questions (e.g., measuring number of steps to reach the goal, comparison with LLM-based methods, measuring wall-clock time).
Decision: Accept (poster)