SLAP: Shortcut Learning for Abstract Planning
Authors: Y. Isabel Liu
Bowen Li
Benjamin Eysenbach
Tom Silver
Venue: ICLR 2026 Poster (2026)
Keywords: Robot Planning
Reinforcement Learning
Primary area: applications to robotics, autonomy, planning
TL;DR: We use RL to learn shortcuts in the abstract planning graph induced by predefined options.

Abstract: Long-horizon decision-making with sparse rewards and continuous states and actions remains a fundamental challenge in AI and robotics. Task and motion planning (TAMP) is a model-based framework that addresses this challenge by planning hierarchically with abstract actions (options). These options are manually defined, limiting the agent to behaviors that we as human engineers know how to program (pick, place, move). In this work, we propose Shortcut Learning for Abstract Planning (SLAP), a method that leverages existing TAMP options to automatically discover new ones. Our key idea is to use model-free reinforcement learning (RL) to learn *shortcuts* in the abstract planning graph induced by the existing options in TAMP. Without any additional assumptions or inputs, shortcut learning leads to shorter solutions than pure planning, and higher task success rates than flat and hierarchical RL. Qualitatively, SLAP discovers dynamic physical improvisations (e.g., slap, wiggle, wipe) that differ significantly from the manually-defined ones. In experiments in four simulated robotic environments, we show that SLAP solves and generalizes to a wide range of tasks, reducing overall plan lengths by over 50\% and consistently outperforming planning and RL baselines.

SLAP: SHORTCUT LEARNING FOR ABSTRACT PLANNING
Y. Isabel Liu
Bowen Li
Benjamin Eysenbach?
Tom Silver?
Princeton University *Carnegie Mellon University isabel. www.pprincetoo.
ABSTRACT
Long-horizon decision-making with sparse rewards and continuous states and actions remains fundamental challenge in Al and robotics. Task and motion planning (TAMP) is a model-based framework that addresses this challenge by planning hierarchically with abstract actions (options). These options are manually defined, limiting the agent to behaviors that we as human engineers know how to program (pick, place, move). In this work, we propose Shortcut Learning for Abstract Planning (SLAP), method that leverages existing TAMP options automatically discover new ones. Our key idea is to use model-free reinforcement learning (RL) to learn shortcuts in the abstract planning graph induced by the existing options in TAMP. Without any additional assumptions or inputs, shortcut learning leads to shorter solutions than pure planning, and higher task success rates than flat and hierarchical RL. Qualitatively, SLAP discovers dynamic physical improvisations (e.g., slap, wiggle, wipe) that differ significantly from the manually- defined ones, In experiments in four simulated robotic environments, we show that SLAP solves and generalizes to a wide range of tasks, reducing overall plan lengths by over 50% and consistently outperforming planning and RL baselines.
Project repository: https: /ttp:::///itttie com isabel LSAA
INTRODUCTION
Long-horizon embodied tasks are fundamentally challenging for modern model-free decision-makingg systems (Mao et al., 2024) due to sparse rewards, complex physical interactions, and the need for generalization in continuous state and action spaces. Task and motion planning (TAMP) (Garrett et al., 2021; Dantam et al., 2016; Srivastava et al., 2014; Kaelbling & Lozano-Pérez, 2011; Toussaint, 2015; Lin et al., 2023) is a classical, model-based framework that uses state and action abstractions to meet these challenges. However, most existing TAMP systems rely pick, place, and move, which make strong assumptions about the physical interactions between the agent and the environment (Wang et al., 2021; Mandlekar et al., 2023; Liang et al., 2024). As result, agents are limited to behaviors that we as human engineers know how to manually program.
pre-defined skills (options) such as
For example, consider the task shown in Figure where tower of obstacles must be disassembled so that target block can be placed on a specific region. Blocks-world tasks like this one have been used benchmark planning methods for decades (Slaney Thiébaux, 2001; Ghasemipour et al., 2022), and it is now easy to find plan that unstacks the obstacles one-by-one before picking and placing the target block. This solution satisficing (Röger & Helmert, 2010), but also long and inefficient. A clever child would find better one: pick up the target block immediately, then "slap" the obstacle tower aside before placing the target. Such short and dynamic solution beyond the capabilities of TAMP and other classical planners, which typically assume that the agent makes contact with objects only through its fingertips (Billard & Kragic, 2019) and that each skill influences only small, pre-specified set of objects (cf. the STRIPS assumption (Fikes & Nilsson, 1971)).
How can an intelligent agent autonomously improvise skills that transcend traditional assumptions in robot programming and lead to better (shorter) overall plans? Previous work in hierarchical reinforcement learning (RL) has considered discovering options from low-level environment cues, often with entropy-based objectives (Kulkami al., 2016; Andrychowicz et al., 2017; Nachum et al.,

---

Execution Time
SLAP (Ours)
2002
Initial State
Pure Planning
Goal
B
on
Pure Reinforcement Learning
Shortcut Learning for Abstract Planning (SLAP) uses reinforcement learning (RI.) to find low-level shortcuts in abstract plans. SLAP finds shorter trajectories than pure planning and achieves higher success rates than pure RL.
Figure 1:
2018; Haarnoja et al., 2018; Eysenbach et al., 2019; Savinov et al., 2018). These tabula rasa methods have had limited success in the long-horizon robotic manipulation tasks that motivate our work.
Rather than learning new skills from scratch, we are interested in the practical setting where a limited set of manually defined skills is available and wish to learn new ones. Our key insight is that the high-level structure of existing skills can guide learning new skills that yield better (shorter) plans. We propose Shorteut Learning for Abstract Planning (SLAP). method that uses RL to learn new options in the abstract planning graph induced by existing skills. Specifically, SLAP identifies promising shortcut connections between abstract states and instantiates RL option-learning environments with goal-based rewards. At inference time, SLAP leverages these learned options to generate shorter plans. For example, in the blocks task, after picking up the target block with a given skill, the robot uses the learned slap shortcut to clear the target region, then place the block on the target.
From a user's perspective, SLAP is a plug-and-play module: whenever one seeks to improve the execution efficiency of an abstract planner in given domain, SLAP autonomously learn shortcuts without additional user input. In the extremes, if shortcuts are too difficult to learn, SLAP reduces pure planning: if the tasks easy, SLAP reduces to pure RL-the plan collapses into a single shortcut. In between, SLAP automatically navigates this spectrum between planning and learning.
We evaluate SLAP in four robotic environments featuring long horizons, sparse rewards, and complex physical interactions. Across all environments, SLAP consistently achieves higher success rates than flat and hierarchical RL, and shorter execution times than pure planning. In additional analyses, find that the number of shortcuts discovered by SLAP increases throughout training time, yielding commensurate improvements in output plan lengths, and that SLAP can generalize tasks with new and different numbers of objects than seen during training. To the best of our knowledge, SLAP is first method that learns low-level skills improving the execution time an abstract planner. This represents progress toward unified system with the improvisational flexibility of RI. and the long-horine morghorizon reasoning and generalization capabilities of TAMP.
2 RELATED WORK
Task and Motion Planning. Task and Motion Planning (TAMP) combines high-level symbolic reasoning with continuous geometric motion planning to solve long-horizon, complex robotic tasks. Task planning decomposes unstructured, long- morizon problems into smaller symbolic subproblems (Fikes Nilsson, 1971; Bonet Geffner, 2001), while motion planning finds collision free paths via sampling (Kavraki al., 1996; LaValle & Kuffner Jr, 2001; Karaman & Frazzoli, 2011)
2

---

trajectory optimization (Ratliff et al., 2009; Schulman et al., 2014). A significant body of work in robotics studies the tight coupling between task planning and motion planning (Kaelbling & Lozano- Pérez, 2011; Dantam et al., 2016; Toussaint, 2015; Srivastava et al., 2014; Garrett et al., 2020). Our abstract planner is intentionally simple- without heuristics or continuous skill optimization to isolate shorteut learning, though more TAMP techniques can be integrated to get orthogonal benefits.
Learning for Task and Motion Planning. Our work is related to recent efforts that combine ideas from TAMP and machine learning. Previous works have considered learning state abstractions (Silver et al., 2023; Han et al., 2024; Shah al., 2024; Asai & Fukunaga, 2018; Ahmetoglu et al., 2022; Li et al., 2025) and action abstractions (Silver et al., 2022; 2021b; bb; Cheng & Xu, 2023; Agia et al., 2023; Mandlekar et al., 2023; Kokel et al., 2021; Yang et al., 2018; Lee et al., 2022; Illanes et al., 2020) to make TAMP possible. We instead assume that these abstractions are given and focus on learning to improve upon them. Other works have considered using learning to accelerate TAMP, e.g., by learning heuristics (Driess et al., 2020; Chitnis et al., 2016), object- based abstractions (Silver ct 20-22022a Zhang et al., 2024), or compiled policies (McDonald & Hadfield-N Menelll, 2022; Dalal et al. 2023; Katara et al., 2024). These approaches accelerate the planning process itself, rather than learning new low-level behaviors for the rohot, as we do here. Other works use RL. to learn recovery policies that bring the robot back to abstract state when execution diverges from abstract plan, e.g., when something novel in the environment occurs (Jiang et al., 2018; Li et al., 2024; Vats et al., 2023; Sarathy et al., 2020; Goel et al., 2022). We instead assume that our given TAMP skills are sufficiently robust that recovery is not necessary, and focus on improving solution efficiency.
Hierarchical Reinforcement Learning. Our work is related to recent efforts in hierarchical RL which assume that prior knowledge about the high-level policy is available and focus on learning low- level skills (Kokel et al., 2021; Yang et al., 2018; Lee et al., 2022: Illanes et al., 2020; Jothimurugan et al., 2021; Icarte et al., 2018). In general, hierarchical RL focuses on the problem of decomposing long-horizon, complex tasks into hierarchy of simpler subtasks, where high-level policy selects subgoals for low-level skills to reach. Previous works bridge planning and hierarchical RL (Allen et al., 2023), e.g.. by constructing goal graphs from replay buffers and using graph search to decompose tasks into reachable waypoints (Eysenbach et al., 2019; Savinov et al., 2018). In contrast, our work aims to use RL to improvise low-level behaviors for short execution times while leveraging prior knowledge from the abstract planner for task decomposition and high-level decision-making.
3 PROBLEM FORMULATION
Following previous work in TAMP, (c.g., see Garrett et al. (2021) for a survey), we develop our approach in fully-observable and deterministic environments with continuous states and actions; however, see Appendix D.4 for additional results with weaker assumptions. Given state x E X' and action u E U1 the next state x' E X is determined by a known transition function f X' 4 + X (e.g., a physics simulator). We consider goal-based tasks (Io, g) where xo E X is an initial state and (To, 44, Ti,........ ur, ur, where Ty 9 and It = ff u.) for all 1 < t < T. Our objective is to minimize [r], the number of time steps in т. If actions are executed at fixed rate, this is equivalent to minimizing execution time. We consider distribution of tasks and assume access to a set of training tasks from the distribution. The agent is allowed training time and then evaluated on held-out tasks from the same distribution.
g C X is goal. A solution to a task is a trajectory
We further suppose that the agent has access to a partitioning of the state space that we refer to as the abstract state space. Let S denote an abstract state and abstract(z) For simplicity, we assume that each task goal g is equivalent to the union of one or more abstract states: g = Us,es, $y. A key insight from both TAMP and hierarchical RL is that abstract states can make planning easier. typical approach (Srivastava al., 2014; Silver et al., 2022) to define options (Sutton et al., 1999; Eysenbach et al., 2018) that each bring the agent from one abstract state to another. An option a E A is characterized by an initial abstract state da E S, a terminal abstract state s and policy n² X - U. When the option is initiated in x such that abstract(z:) = ofi the policy x" is executed until the terminal abstract state & is reached. We assume that a given finite set of options A is sufficient for generating solutions for goals in our task distribution. However, these solutions will often be highly suboptimal with respect to execution time. We are interested in using training to learn to improve on execution time during evaluation.
denote if s.
3

---

4 SLAP: SHORTCUT LEARNING FOR ABSTRACT PLANNING
We now describe Shortcut Learning for Abstract Planning (SLAP), our proposed method for learning improve the execution time of an abstract planner. A summary of our algorithm presented in Figure and we also illustrate SLAP via pseudocode in Algorithms I and 2.
4.1 PLANNING WITH ABSTRACT STATES
We begin by considering planning: given a task (æo. g) and op- tions A, how can we find solutions that minimize execution time? We propose to build and search within an abstruct planning graph (Figure 2). The graph has two levels. the top level, nodes repre- sent abstract states and edges represent options. In the bottom level, nodes represent environment states and edges represent environment actions. The levels related in that bottom-level edges correspond to top-level edge executions. To build the graph, we start at the root nodes (wo on the bottom and abstract(ro)) on the top) and simulate options given the known transition function. We build the graph breadth-first until we reach some nodes where the goal is satisfied. Given a built graph, we can run any shortest path algorithm (e.g., Dijkstra's) 's) the bottom level to find an solution. This abstract planning graph is constructed similarly to the bilevel graphs used previous works (Silver et al., 2022; 2023; Li et al., 2025). See Appendix A. for details,
Ki Up
U2
* Goal
Shortest path
Figure 2: Abstract planning graph. Top level has abstract states and options Bottom level has states x and actions u.
4.2 LEARNING SHORTCUTS WITH RL
The trajectories found by planning with the given options may be highly suboptimal, espe- cially if the options were designed with strong simplifying assumptions about robot contact and single-object manipulation (Billard & Kragic, 2019). We propose that the agent should use training learn shortcuts between abstract states to discover new low-level behaviors that may reduce execution time. shortcut is an option à (Smit, To, Stem) where Sini and Stemm are a pair of abstract states not already achieved by any given option, and me is policy with learnable parameters E RR". The shorteut in Figure uses learned "slap" policy get from an abstract state where the target block is held to abstract state where the target region is clear.
Algorithm 1: SLAP Training
Data Collection (offline)
input: ((zo,g)),f Neatter
init: <- O
// shortcut data
foreach (.r..g) )) do
for 1 to Newtiver do
G BUILDGRAPH(ZU,, 9, A.
D GEYSHORICCIDATA(()
D PRUNE(D,
// rollouts
D.uddate(D)
return D
Training (offline) input: f.D
11 from data collection I/ learned shortcuts do M &- CREATEMDP Binit; Stern f)
init: Å+ d+1
foreach (Sinit, Summ No)
During training, we spawn multiple self- contained environments and learn shorteut poli- cies in parallel. The environment for a short- from Sinir Stemm is an sndefinite-horizor Markov decision process (MDP) with state space X, action space 2, transition function f. reward function R(z) = -1, and terminal states Stem- To create initial state distribution, we do not assume that we can sample directly from Siniti instead, we sample from the states encountered in the abstract planning graphs for the training tasks. Given this setup, we can use any continuous-state-ane and-acioon RL algorithm to learn shortcut policies (see Appendix B.2 for ablations). We use proximal policy optimization (PPO) (Schulman et al., 2017).
It + LEAR
A.ad(((smn) (Sinit: 8tems TTg)
return Á
A Algorithm SLAP Evaluation
Evaluation (online)
input: (Zo.g), f. A, Á
G BUILDGRAPHETO.. A. Á.A
7 DUKSTRA(G)
return
4

---

Shortcut MDP
Shortout MDP
Shortcut Policy
Shortout MDP
Fruned w/ Rollicuts
Intlil States
Goal
M.
clear
Siuulaoo
Tt
a. Build Graph
b. Get Shortcut Data
c. Training
d. Evaluation
Tafoy, 2r) afog, x))
Generalizing to New, More, and Fewer Objects
Generalizing Tasks
afn x))
Relevant Object State Projection
8. Generalization
Figure 3: SLAP Pipeline. (a) We build abstract planning graphs on training tasks and generate possible shortcuts. (b) Each shorteut induces an MDP. (c) We RL in parallel shortcut MDPs to create shortcut policies. (d) The learned policies are used to find shortcuts in abstract planning graphs for new evaluation tasks. (e) SLAP generalizes over tasks (initial states and goals) and objects.
The number of potential shortcuts is O(SS)), which can be large. We propose a simple pruning mechanism that we found be effective in practice. For each shorteut-leaming MDP, we start by executing Noolee random rollouts of up to length Tollouu from the initial state. If Stem is reached fewer than K rollouts, we prune the shortcut and do not run RI. The intuition behind this pruning is that RI needs some initial success to bootstrap policy learning. See Appendix B. for ablation studies on hyperparameter choices and additional results on the effectiveness of pruning.
4.3 PLANNING WITH LEARNED SHORTCUTS
Presented with new task evaluation, we run the same abstract planner in Section 4.1, but with the learned shortcut policies added to the original set of options. Since shortcut policies may fail, we check the abstract terminal state reached within Teval steps and prune the edges in the case of failure (see Figure 3d). Successful shortcuts are automatically selected by the planner when they enable shorter plans. See Appendix D.2 for analysis on test-time planning and execution efficiency.
By planning with learned shortcuts, we can generalize to new tasks that have initial states and goals not seen during training. Generalization over states is achieved by the shorteut policies. This low-level generalization need not be perfect-if some shortcuts work in some tasks, will already see benefits over pure planning. Generalization over goals is achieved by the planner, which runs search for each new goal and selects shortcuts accordingly (see Appendix D.1 for results).
Overall, our method-Shortcut Shortcut Learning for Abstract Planning (BLAP)-allowe us to navigate the spectrum between pure planning and pure RL. If the given options A are already optimal, or if shortcut learning is too hard, SL.A reduces to pure planning. the environment simple enough for RI, and shorteut policies can be learned directly from the initial state to the goal, SLAP reduces to pure RI. In other cases, SLAP automatically discovers a middle ground between planning and RI.
4.4 GENERALIZING OVER OBJECTS
TAMP methods typically assume that states are defined by objects and relations (Garrett et al., 2021). In this section, show how SLAP can leverage the same assumption generalize over objects, solving held-out tasks with new, more, and fewer objects than those seen during training.
Following previous work (Diuk et al., 2008; Silver et al., 2022; 2023), suppose that each state I E X' is defined by a set of objects O and feature vectors (0, E R for each object o e O. For example, the features for block in Figure include & position and yaw orientation, among others.
5

---

We also suppose that each abstract state E S defined by finite set of atoms, which are discrete relations between objects, e.g., {on(B, C), on(C,, D). hoo....,ol ho))
During shorteut learning, we first use the relations in the abstract states to decide which atoms and objects are relevant for each shortcut (Silver et al., 2022). For a shortcut = (Simis To. Summ) let (ad be the set of atoms present in 8temm but absent in Smits and let del(ā) be those in Sini but not in Stem- For example, à corresponds to grasping object B, then holding( B) E add(ā) and gripperEmpty() E (a)( add(ā) and del(ā) compose the relevant atoms for the shorteut, and rel(ā) S O is the set of relevant objects that appear in any of the relevant atoms.
We the relevant objects to define state projection proja (1) a(or, (1) o.... o(oo, where E ree((a) for some fixed object ordering and where denotes vector concatenation. When training the policy for the shorteut à, we use the projected state as the observation input. As result, adding irrelevant objects to the environment has no impact on the policy.
During evaluation, when presented with new objects, the agent considers object substitutions for each shortcut that would render the shortcut equivalent to some shorteut seen during training. Formally, given a pair of shortcuts (deriin deval): we check if there is type-preserving injective object mapping rel + rre(a) such that
{ 0g E add(@rrain) } C add(
{a, : E del(@rrain) }
S (@vvaa))))
where On denotes the atom obtained by replacing each object in the atom a with its image under For an example of object substitution for shortcuts, see Section 5.1. a matching object substitution is found, the respective learned shorteut policy is deployed using the substituted objects as inputs. See A.2 for details and pseudo-code.
5 EXPERIMENT
We next present experiments and results to address the following questions about the efficiency and effectiveness of SLAP:
Q1. To what extent can SLAP find shorter plans compared pure planning?
Q2. How does the sample efficiency of SL.AP compare to that of pure RI and hierarchical RI.?
Q3. Does SLAP continue to improve and discover new shortcuts throughout training?
Q4. To what extent can SLAP generalize to new tasks and new objects?
Q5. Which RL design decisions are important for learning shortcuts?
Our open-source code is available online at https:///ithht: wtw.ttttb...oomttooem com http:://gtttnbbcomm//eaaaa//////
System, Hardware, and Compute Footprint We conduct all experiments on a single H100 GPU with 4 CPU cores. Training is conducted on the same hardware as evaluation. We report the compute footprint of shortcut learning with parallelized training across subprocesses.
Environment
# Shortcuts Env Interactions
RL Time
Obstacle 2D
(4.1 1.2) 106
~ min
Obstacle Tower
92
(4.8 x 107
h
Cluttered Drawer
74
(3.3 0.5) 10?
Cleanup Table
54
(3.2 1 (..) 107
~
Environments. We evaluate our methods in four simulated robotic environments that feature long horizons, sparse rewards, and continuous states and actions. A brief overview of the environments is provided below; see Appendix for further details and visualizations of our environments.
Obstacle 2D: Inspired by the "Cover" environment (Chitnis et al., 2022; Silver et al., 2021b; 2023). a 2D planar robot with gripper must move a target object into designated region that initially occupied by an obstacle. The initial options A implement picking and placing. Without shorteuts, the planner would pick and place the obstacle, then pick and place the target object.
Despptte being in 2D, this environment is difficult for Pure RI because precise actions required to execute grasping. We verified that weakening the threshold for grasping leads 100% success for the Pure RI. haselines.

---

Obstacle Tower: As illustrated in Figure 1, a 7-DoF Franka Emika Panda robot arm, simulated in PyBullet (Coumans Bai, 2016), must move a target block into a target region that is initially occupied by tower of obstacles. The initial options implement picking and placing with BiRRT for motion planning and Fast for inverse kinematics. Without shortcuts, the planner would pick and place each obstacle in the tower, then pick and place the target object.
The same Franka robot simulated in PyBullet must retrieve an object from within a cluttered drawer and place it on top of a table. The initial options implement picking and placing, again with BiRRT and IKFast. Since the target object is tightly surrounded by other objects, the planner (without shortcuts) would pick and place neighboring objects until a feasible grasp exists for the target, then pick and place the target object.
Cluttered Drawer:
Cleanup Table: This PyBullet environment features realistic and irregular 3D objects from Objaverse (Deitke et al., 2023). The same Franka robot must collect three toys (duck, robot, dinosaur toys) and a wiper from the table and organize them in the storage bin on the floor beside the table. The initial options implement picking and dropping, again with BiRRT and IKFast. Without shortcuts, the planner picks up each object from the table and drops it into the bin.
We now briefly describe the methods that we compare in experiments, with implementation details provided in Appendix C.
Methods Evaluated.
Shortcut Learning for Abstract Planning (SLAP): Our main approach.
Pure Planning: The same abstract planner used by SLAP (Section 4.1), but without shortcuts.
Pure RL (PPO): Proximal policy optimization (Schulman et al., 2017) operating in the low- level joint state space of the robot on the full task with sparse reward function that penalizes execution time (plan length). Note that SLAP shortcut learning also uses PPO.
Pure RL (SAC+HER): Given our focus on sparse-reward environments, we also compare against hindsight experience replay (HER) (Andrychowicz et al., 2017), which designed to handle sparse rewards. We use soft actor-critic (SAC) (Haarnoja et al., 2018) as the base algorithm (which must be off-policy).
Hierarchical RL (PPO): Hierarchical RL outputs both low-level actions and skill selection probabilities. When skill activations exceed threshold 0.5, the top skill is executed until com- pletion; otherwise, lowelevel actions used. Similar to SLAP, Hierarchical RL has access to predefined skills, following modular HRL methods like MAPLE (Nasiriany et al., 2022), which dynamically select and compose behavior primitives to solve long-horizon manipulation tasks.
SOL: Based on state-of-the-ard hierarchical RL method Scalable Option Learning (Henaff et al., 2025), we adapted the algorithm to also have access to both predefined skills and SLAP's shortcut data. SOL jointly learns a high-level controller that selects between predefined skills and shortcuts, and low-level shortcut policies. Predefined skills are frozen throughout training, same the high-level priors that SLAP and Hierarchical RL (PPO) leverage, while SLAP's shortcut data provide the intrinsic rewards that SOL requires.
Experimental Details. We begin by collecting training tasks and graphs as outlined in Algorithm 1. We sample 10 tasks (zo. g) for each environment. In main experiments, for the sake of comparing with RL methods, we use a fixed goal g, but note that SLAP and Pure Planning can generalize to new goals (Appendíx D.1). At evaluation, we sample 10 held-out tasks per environment and measure (i) success rate and (ii) plan length, which is equivalent to execution time assuming that environment actions are executed
fixed rate. For RL, we use bable-baseelins? (Raffin et al., 2021) and train each policy for 500,000 steps to obtain the results in Table 1. All PPO policies (shortcut learning, Pure RL, and Hierarchical RL) use the same network architecture and training hyperparameters, except for longer training time and higher entropy coefficient for RL baselines- we tune this to give RI. an advantage in exploration. All reported metrics are averaged over random seeds with standard deviations. Additional i implementation details and hyperparameters are provided in Appendix B & C.
5.1 RESULTS AND DISCUSSIONS
Empirical Results. Table summarizes our empirical results. SLAP consistently reduces plan length by large margins compared to Pure Planning. These results highlight the effectiveness of the
7

---

Environment
Approuch
Success Rate
Plan Length
Relative Path Length
SLAP (Ours)
100% 1: 0%
17.6 +: 1.5
32% + 7%
Pure Planning
100% + 0%
25.9 + 1.7
0%
PPO
0% + 0%
100.0 + 0.0 (max)
N/A N/A
Obstacle 2D
SAC+HER
0% + 0%
100,0 1 0.0 (max)
Hierarchical RL
100% 0%
25.3 1.8
4 2% = 9%
SOL
100% + 0%
21.9 1.2
4.4% = 8%
SLAP (Ours)
100% 0%
79.2 3.2
68% + 2%
Pure Planning
100% 0%
245.8 10.4
0%
Obstacle Tower
PPO
0% + 0%
500.0 1 0.0 (max)
N/A
SAC+HER
0% = 0%
500.0 + 0.0 (max)
N/A
Hicrarchical RI
0% + 0%
500.0 + 0.0 (max)
N/A
SOL
0% + 0%
500.0 +: 0.0 (max)
N/A
SLAP (Ours)
100% 0%
165.8 43.6
4 53% + 14%
Pure Planning
100% 0%
352.1 49.5
0%
Cluttered Drawer
PPO
0% +
500.0 - 0.0 (max)
N/A
SAC+HER
0% + 0%
500.0 + 0.0 (max)
N/A
Hierarchical RL
0% + 0%
500.0 1 0.0 (max)
N/A
SOL
0% = 0%
500.0 + 0.0 (max)
N/A
SLAP (Ours)
100% + 0%
115.2 + 12.3
73% + 4%
Pure Planning
100% + 0%
431.8 + 33.1
0%
Cleanup Table
PPO SAC+HER
0% + 0%
500.0 1 0.0 (max)
N/A
0% +
500.0 0.0 (max)
N/A
Hierarchical RL
0% + 0%
500.0
0.0 (max)
N/A
SOL
0% 0%
500.0 + 0.0 (max)
N/A
Table 1: Main Empirical Results. We report average performance over 10 random seeds with standard deviations. SLAP successfully solves the long-horizon tasks and achieves substantially shorter plans-uy up to a 73% reduction in plan length-compared to Pure Planning.
shortcuts learned by SLAP (Q1). In contrast, pure RL methods struggle to solve these tasks, largely due the sparsity of reward signals, which received only upon task completion. Even though hierarchical RL methods can mitigate this issue and have additional access to our predefined skills, their high-level controllers struggle to learn the skill selection sequence given the large number of grounded skills in manipulation tasks (Q2). For example, SOL needs to deal with 216 grounded skills in Obstacle Tower, compared to 2-3 option policies in the NetHack Learning Environment (Küttler et al., 2020) it was evaluated on in Henaff et al. (2025).
Training Steps Analysis. To understand how training time affects performance, we analyze the relationship between shortcut policy training steps and plan lengths (Q3). After random rollout pruning. SLAP identifies 11 shortcuts in Obstacle 2D, 92 in Obstacle Tower, 74 in Cluttered Drawer, and 54 in Cleanup Table. As shown in Figure 4, increasing the number of training steps leads to more shortcuts being successfully learned from the fixed set of shortcut candidates and incorporated as graph edges during evaluation. Average plan lengths continue to decrease towards the end of 500,000 training steps as the same shortcut policies become more stable. The marginal benefit varies by environment complexity.
Generalization Capability Analysis. We next evaluate the extent which SLAP can generalize to tasks with new, more, and fewer objects as well as to changes in dynamic properties (Q4). We focus on mass and friction, which most strongly affect multi-object interactions in our preliminary tests. SLAP is trained in Obstacle Tower with three stacked obstacles (each with mass 0.5kg and friction coefficient 0.9), and then evaluated on tasks with varying numbers of stacked obstacles and distractor objects scattered on the table using doubled mass and friction at test time. As shown in Figure: 5, SLAP maintains short plan lengths even as the number of objects increases, whereas Pure Planning scales poorly with each additional obstacle. These multi-object RL skills ("slap", "wiggle", "wipe")) unlike TAMP methods that assume single-object contact (Billard & Kragic, 9019)-both both improve execution efficiency and support generalization over the number of objects. For example, the "slap" shortcut policy shown in Figure 5 only deems a subset of the obstacles relevant but physically affects the entire tower.
8

---

Plnntroth (ntep)
Obstacce
Obstacle Tower
Cluttered Drawer
Cleanup Table
SEAP
SEAP
SLAP
SLAP
390
Plaasay
300
300
290
200
300
030
231
300
MLAP
41A7
Traming Sharteut (=1020)
Training Shartoun 0010000)
Truining Skeeteut (ctcod)
Traislng Sacetictt (11000)
Execution Time
SLAP Output Plan with Shortcut by 50,000 training steps per shortcut
298.3 7.8 steps
Initial State
SLAP Output Plan with Shortcuts ① i
by 250,000 training steps shortcut
176.8 * 21.5 steps
on
SLAP Output Plan with Shortcuts 3
by 400,000 training steps per shortcut
171.6 steps
Figure 4: Training Dynamics. As the number training steps increases, more shorteuts are added and the length of the output SLAP plan decreases. In Cluttered Drawer, visualize SLAP's output plans after different training steps to illustrate which shortcuts are learned and used over time.
Planning
add Kan 3 talk)) (on tabie lon Oectiingon target)
Pla Lesgth (steps)
300
SLAP
BE
StAP (2x Mass&Friction)
del: Ken 8 target), (on ton Ci
200
Subetitution ott) oc3)
1000
add: Kin a taklet (on table). fon D uuboe) (ce abble. (nsthingtn terett
dal: Ken 5 tarae). (su C ton CJ ton D.D
(1000) (3,00,))).)) (9 stacked blocss, scaltered blocks, mass&ttriction multiplier)
(5,5))
Figure 5: Generalization Results. In Obstacle Tower, SLAP is trained tasks with stack of obstacles, no distractors. At test time, we are able to generalize to tasks with different numbers of obstacles and distractors, each with different mass and friction, by substituting relevant objects.
Shortcut Policy Learning Analysis: SLAP learns separate shortcut policies for each pair of
abstract states. While this parallelization makes distributed training easier, also possible that training universal policy (Kaelbling, 1993; Schaul et al., 2015; Eysenbach et al., 2022) could lead to better sample complexity, with learned representations shared across shortcuts (Q5). To test this possibility, we compare three shortcut policy learning schemes:
Independent: We train all shorteut policies separately (the default for SLAP).
Abstract Subgoals: We augment observations with multi-hot encoding of the abstract terminal state for the respective shortcut and train a single shared policy for all shorteuts.
We the same multi-hot abstract terminal state encoding as in Abstract Subgoals, but we additionally perform hindsight goal relabeling (as in HER) where goals are now abstract terminal states. During training, if the shorteut policy reaches different abstract terminal state from the one was targeting, that data is used to learn about the shortcut that was incidentally achieved. We again SAC for compatibility with HER.
Abstract HER:

---

Obstacle 2D
Obstacle Tower
Cluttered Draver
Cleanup Table
200
300
Plan Lengst (Stpp))
300
300
13
100
Indepesdeek
Abdeas:
Indepeeddzzt. Mantous
Pare Plattin
Indepondasi Abrirstt Nayel
Abotact Pure
Batgoa
Planning
Salgya
Plansing
Phaziy
Figure 6: Shortcut Policy Learning Analysis. Independent shortcut policy learning consistently finds shorter plans than Abstract Subgoal and Abstract HER.
In Figure 6,
that Independent consistently outperforms Abstract Subgoals and Abstract HER, particularly in PyBullct environments, despite the opportunity to share representations across shorteuts. We speculate that the poor performance of universal policy learning is due to the fact that shortcuts have varying levels difficulty for RL. Universal policy learning may implicitly devote resources to learning infeasible shortcuts, where Independent would simply fail learn on those shortcuts. In future work, we plan to continue exploring shortcut policy learning schemes. We further ablate RL algorithmic choices for shorteut learning Appendix B.2, with different reward-shaping and exploration strategies (Q5).
DISCUSSION AND CONCLUSION
In this work, proposed Shortcut Learning for Abstract Planning (SLAP). Our key insight is that the abstract planning graph induced by predefined skills presents an opportunity to learn shortcuts that improve the execution time of pure planning. In experiments, found by SLAP are better than pure planning in terms length, and better than pure RL in terms of success rate. We also showed that SLAP can leverage the same relational inductive bias that TAMP uses to solve tasks that feature new, more, fewer objects than those seen during training.
showed that the trajectories
One limitation of SLAP is that it not able to deviate from the problem decomposition induced by the user-provided options. Future work could consider using the options to instead provide "soft" problem decomposition that can be further improved by hierarchical RL (Kulkarni et al., 2016; Bacon et al., 2017; Nachum et al., 2018), Another limitation of our work here is that our planner is simple from a TAMP perspective (Section 2). Scaling very large abstract spaces would benefit from more advanced planning techniques (Garrett et al., 2021). We also made the assumption in this work that usev-provided options are sufficient for solving tasks. Without this assumption, SLAP still applies, but we lose the guarantee of task success. However, in this case, the shortcuts learned by SLAP could improve on the task success rate of pure planning; see Section D.3 for detailed discussion. In addition, because SLAP learns shortcut behaviors that fall outside the set of manually defined options, its execution can be less predictable than traditional TAMP: future work can incorporate safety constraints into shorteut learning. Another direction for future work is combining SLAP with other work that learns abstractions for abstract planning. For example, with demonstration data, could first learn state abstractions with Silver et al. (2023), action abstractions with Silver et al. (2022), and then leverage our SLAP framework to continue improving the planning efficiency. A final opportunity extend SLAP is remove our assumption of access to simulator and, instead, leverage the recent real-to-sim-to-e to-rell techniques (Lim et al., 2022; Zhu et al., 2025) to reconstruct approximate simulators from real-world data and learn shortcut policies within those reconstructed environments.
REPRODUCIBILITY STATEMENT
To support reproducibility, provide the full souree code and models part of the supplementary materials. All hyperparameters, environment details, and implementation specifics necessary to reproduce the experiments reported in Appendix & C.
10

---

8 ACKNOWLEDGMENTS
We thank Danfei Xu, Chongyi Zheng, and Yixuan Huang for comments on an earlier draft. We would like to give special thanks Princeton Research Computing" for supplying us with the compute that makes our experiments possible.
REFERENCES
Christopher Agia, Toki Migimatsu, Jiajun Wu, and Jeannette Bohg. Stap: Sequencing agnk- policies. In 2023 IEEE International Conference on Robotics and Automation (ICRA), pp. 7951- 7958. IEEE, 2023.
Alper Ahmetoglu, M Yunus Seker, Justus Piater, Erhan Oztop, and Emre Ugur. Deepsym: Deep symbol generation and rule learning for planning from unsupervised robot interaction. Journal of Artificial Intelligence Research (JAIR), 2022. URL https: /www. jair org/ index. php/ bsir/articceeviee//1a 22688
Cameron Allen, Timo Gros, Michael Katz, Harsha Kokel, Hector Palacios, and Sarath Sreedharan. Bridging the gap between planning and reinforcement learning (prl@ ijcai 2023). In International Joint Conference on Artificial Intelligence, 2023.
Marcin Andrychowicz, Filip Wolski, Alex Ray, Jonas Schneider, Rachel Fong, Peter Welinder, Bob McGrew, Josh Tobin, OpenAl Picter Abbeel, and Wojeiech Zaremba. Hindsight experience replay. Advances in neural information processing systems, 30, 2017.
Masataro Asai and Alex Fukunaga. Classical planning deep latent space: Bridging the subsymbolic- symbolic boundary. In AAAI Conference on Artificial Intelligence (AAAI), 2018. URL https: //www. aaai..... org/ ocs/ index...... php/ AAAI AAAAI8 http//ppppeeeeeeeeeeeeeeeeeeeeee
Pierre-Luc Bacon, Jean Harb, and Doina Precup. The option-critic architecture. In Proceedings of the AAAI conference on artificial intelligence, 2017.
Aude Billard and Danica Kragic. Trends and challenges in robot manipulation. Science, 364(6446): caat8414, 2019.
Blai Bonet and Héctor Geffner. Planning as heuristic search. Artificial Intelligence, 129 2001.
Shuo Cheng and Danfei Xu. League: Guided skill learning and abstraction for long-horizon manipulation. IEEE Robotics and Automation Letters, 8(10):6411-6458 2023.
Rohan Chitnis, Dylan Hadfield- Abhishek Gupta, Siddharth Srivastava, Edward Gro- shev, Christopher Lin, and Pieter Abbeel. Guided search for task and motion plans us- ing learned heuristics. In IEEE International Conference Roboties and Automation (ICRA), 2016. URL 2016 1011-ICRA, taa--ammmmaaneee -empp-eeaningg..m pdf..
Rohan Chitnis, Tom Silver, Joshua B. Tenenbaum, Tomás Lozano-Pérez, and Leslie Pack Kaelbling. Learning Neuro-Symbolic Relational Transition Models for Bilevel Planning. In Proceedings of the IEEE/RSJ International Conference Intelligent Robots and Systems (IROS), pp. 4166 4173, 2022.
Erwin Coumans and Yunfei Bai. Pybullet, a python module for physics simulation for games, robotics and machine learning, 2016. URL http::h/ybbluleeeeeeeee org. Accessed: 2025-04-22.
Murtaza Dalal, Ajay Mandlekar, Caelan Garrett, Ankur Handa, Ruslan Salakhutdinov, and Di- eter Fox. Imitating task and motion planning with visuomotor transformers. arXiv preprint 16300 2023.

---

Neil T Dantam, Zachary K Kingston, Swarat Chaudhuri, and Lydia E Kavraki. Incremental task and motion planning: A constraint-bat approach. In Robotics: Science and systems, volume 12, pp. 00052. Ann Arbor, MI, USA, 2016.
Matt Deitke,
Dustin Schwenk, Jordi Salvador, Luca Weihs, Oscar Michel, Eli VanderBilt, Ludwig Schmidt, Kiana Ehsani, Aniruddha Kembhavi, and Ali Farhadi. Objaverse: A universe of annotated 3d objects. In Proceedings the IEEF/CVF conference on computer vision and pattern recognition, pp. 13142-13153, 2023.
Carlos Diuk, Andre Cohen, and Michael L Littman. An object-oriented representation for efficient reinforcement learning. In International Conference Machine Learning (ICMI.), 2008. URL https://cart http:///aalloooo losdiuk uk thub. io/ pwwpps//oOR.... pdf.
Danny Driess, Jung-Su Ha, and Mare Toussaint. Deep Visual Reasoning: Learning to Predict Action Sequences for Task and Motion Planning from an Initial Scene Image. In Robotics: Science and Systems (RSS), 2020. URL https: //wp::://wwww robot wwwpocceepeingoooooccccoeeeeeeee woggrrssl//ppo pdf.
Benjamin Eysenbach, Abhishek Gupta, Julian Ibarz, and Sergey Levine. Diversity is all you need: Learning skills without a reward function. arXiv preprint arXiv: 2018. URL jRqEm.
https: /ttts:://openrvieww net/ forum?id-SJx6 http://wwwweeeeeooooooii------ee
Benjamin Eysenbach, Ruslan Salakhutdinov, and Sergey Levine. Search on the replay buffer: Bridging planning and reinforcement learning. Advances neural information processing systems, 32, 2019.
Benjamin Eysenbach, Tianjun Zhang, Sergey Levine, and Russ R Salakhutdinov. Contrastive learning as goal-conditioned reinforcement learning. Advances in Neural Information Processing Systems, 35:35603-35620, 2022.
Richard E Fikes and Nils Nilsson. Strips: A new approach to the application of theorem proving to problem solving. Artificial intelligence, 289-4)) 1971.
Caelan Reed Garrett, Tomás Perezo-Pérez, and Leslie Pack Kaelbling. Pddlstream: Integrating symbolic planners and blackbox samplers via optimistic adaptive planning. In Proceedings the international conference on automated planning and scheduling, volume 30, pp. 440-448, 2020.
Caelan Reed Garrett, Rohan Chitnis, Rachel Holladay, Beomjoon Kim, Tom Silver, Leslie Pack Kaelbling, and Tomás Lozano-Pérez. Integrated task and motion planning. Annual review of control, robotics, and autoromous systems, 4(1):265-293, 2021.
Seyed Kamyar Seyed Ghasemipour, Satoshi Kataoka, Byron David, Daniel Freeman, Shixiang Shane Gu, and Igor Mordatch. Blocks assemble! learning assemble with large-scale structured reinforcement learning. In International Conference on Machine Learning, pp. 7435-7469. PMLR, 2022.
Shivam Goel, Yash Shukla, Vasanth Sarathy, Matthias Scheutz, and Jivko Sinapov. Rapid-learn: A framework for learning recover for handling novelties in open-world environments. In 2022 IEEE International Conference on Development and Learning (ICDL), pp. 15-22. IEEE, 2022.
Tuomas Haarnoja, Aurick Zhou, Pieter Abbeel, and Sergey Levine. Soft actor-critic: Off-policy maximum entropy deep reinforcement learning with a stochastic actor. In International conference on machine learning. pp. 1861-1870. Pmlr, 2018.
Muzhi Han, Yifeng Zhu, Song-Chun Zhu, Ying Nian Wu, and Yuke Zhu. InterPre'T: Interactive Predicate Learning from Language Feedback for Generalizable Task Planning. arXiv preprint arXiv:2405.19758, 2024.
Mikael Henaff, Scott Fujimoto, Michael Matthews, and Michael Rabbat. Scalable option learning in high-throughput environments. arXiv preprint arXiv:2509.00m0 00338, 2025.
Jörg Hoffmann. Ff: The fast-forward planning system. Al magazine, 22(3):57-57, 2001.
12

---

Rodrigo Toro Icarte, Toryn Klassen, Richard Valenzano, and Sheila Mcllraith. Using reward machines for high-level task specification and decomposition in reinforcement learning. In International Conference Machine Learning, pp. 2107-2116. PMLR, 2018
León Illanes, Xi Yan, Rodrigo Toro Icarte, and Sheila Mcllraith. Symbolic plans as high-level in- structions for reinforcement learning. In Proceedings of the international conference automated planning and scheduling, volume 30, pp. 540-550, 2020.
Yuqian Jiang, Fangkai Yang, Shiqi Zhang, and Peter Stone. Integrating task-motion planning with rein- forcement learning for robust decision making in mobile robots. arXiv preprint 1..095, 2018.
Kishor Jothimurugan, Suguman Bansal, Osbert Bastani, and Rajeev Alur. Compositional reinforce- ment learning from logical specifications. Advances in Neural Information Processing Systems, 34: 10026-10039, 2021.
Leslie Pack Kaelbling. Learning to achieve goals. In IJCAI, volume pp. 1094 1098. Citeseer, 1993.
Leslie Pack Kaelbling and Tomás Lozano-Pérez. Hierarchical task and motion planning in the now. In 2011 IEEE International Conference on Robotics and Automation, pp. 1470-1477. IEEE, 2011.
Sertac Karaman and Emilio Frazzoli. Sampling- algorithms for optimal motion planning. The international journal of robotics research, 30(7):846-894, 2011.
Pushkal Katara, Zhou Xian, and Katerina Fragkiadaki. Gen2sim: Scaling up robot learning in simulation with generative models. In 2024 IEEE International Conference on Robotics and Automation (ICRA), pp. 6672-6679. IEEE, 2024.
Lydia E Kavraki, Petr Svestka, J-C Latombe, and Mark H Overmars. Probabilistic roadmaps for path planning in high-dimensional configuration spaces. IEEE transactions on Robotics and Automation, 12(4)5566-580, 1996.
Harsha Kokel, Arjun Manoharan, Sriraam Natarajan, Balaraman Ravindran, and Prasad Tadepalli. Reprel: Integrating relational planning and reinforcement learning for effective abstraction. In Proceedings of the International Conference on Automated Planning and Scheduling, volume 31,
pp. 533-541, 2021.
Tejas D Kulkarni, Karthik Narasimhan, Ardavan Saeedi, and Josh Tenenbaum. Hierarchical deep reinforcement learning: Integrating temporal abstraction and intrinsic motivation. Advances in neural information processing systems, 29, 2016.
Nishanth Kumar, Tom Silver, Willic McClinton, Linfeng Zhao. Stephen Proulx, Tomás Lozano-Pérez Leslie Pack Kaelbling, and Jennifer Barry. Practice Makes Perfect: Planning To Learn Skill Parameter Policies. In Proceedings of the Robotics: Science And Systems (RSS), 2024.
Heinrich Küttler, Nantas Nardelli, Alexander Miller, Roberta Raileanu, Marco Selvatici, Edward Grefenstette, and Tim Rocktäschel. The nethack learning environment. Advances in Neural Information Processing Systems, 33:7671-7688 2020.
Steven M Valle and James J Kuffner Jr. Randomized kinodynamic planning. The international journal of robotics research, 20(5):378-400, 2001.
Junkyu Lee, Michael Katz, Don Joven Agravante, Miao Liu, Geraud Nangue Tasse, Tim Klinger, and Shirin Sohrabi. Hierarchical reinforcement learning with planning models. arXiv preprint arXiv:2203.00669 2022.
Alicia Li, Nishanth Kumar, Tomás Lozano-Pérez, and Leslie Kaelbling. Learning to bridge the gap: Efficient novelty recovery with planning and reinforcement learning. arXiv preprint arXiv:2409. /9226, 2024.
Bowen Li, Tom Silver, Sebastian Scherer, and Alexander Gray. Bilevel learning for bilevel planning. In Roboties: Science and Systems (RSS), 2025.
13

---

Yichao Liang, Nishanth Kumar, Hao Tang, Adrian Weller, Joshua B Tenenbaum, Tom Silver, João F Henriques, and Kevin Ellis. VisualPredicator, Learning Abstract World Models With Neuro- Symbolie Predicates For Robot Planning, 2024. URL https::/aaxdd..orraab////// wwtp.///gg/abb//1...0
23156.
Vincent Lim, Huang Huang, Lawrence Yunliang Chen, Jonathan Wang, Jeffrey Ichnowski, Daniel Seita, Michael Laskey, and Ken Goldberg. RealZsim2real: Self-supervised learning of physical single-step dynamic actions for planar robot casting, In 2022 International Conference on Robotics and Automation (ICRA), pp. 8282-8289. IEEE, 2022.
Kevin Lin, Christopher Agia, Toki Migimatsu, Marco Pavone, and Jeannette Bohg. Text2motion: From natural language instructions to feasible plans. Autonomous Robots, 47(8):1345-13655 2023,
Ajay Mandlekar, Caelan Reed Garrett, Danfei Xu, and Dieter Fox. Nlmman-in-the-loge task and motion planning for imitation learning. In Conference on Robot Learning, pp. 3030-3060. PMLR, 2023.
Jiayuan Mao, Tomás Jozzno-Pééczz Josh Tenenbaum, and Leslie Kaelbling. What Planning Problems Can A Relational Neural Network Solve? In Proceedings of the Advances in Neural Information Processing Systems (NeurIPS), volume 36, 2024.
Michael James McDonald and Dylan
Guided imitation of task and motion planning. In Conference on Robot Learning, pp. 630-640. PMLR, 2022.
Ofir Nachum, Shixiang Shane Gu, Honglak Lee, and Sergey Levine. Data-efficient hierarchical reinforcement learning. Advances in neural information processing systems, 31, 2018.
Soroush Nasiriany, Huihan Liu, and Yuke Zhu. Augmenting reinforcement learning with behavior primitives for diverse manipulation tasks. In 2022 International Conference on Robotics and Automation (ICRA). pp. 7477-7484. IEEE, 2022.
Antonin Raffin, Ashley Hill, Adam Gleave, Anssi Kanervisto, Maximilian Ernestus, and Noah Dormann. B Reliable Reinforcement Learning Implementations. Journal of Machine Learning Research, pp. 1-8, 2021.
Nathan Ratliff, Matt Zucker, Andrew Bagnell, and Siddhartha Srinivasa. Chomp: Gradient optimization techniques for efficient motion planning. In 2009 IEEE international conference on robotics and automation, pp. 489-494. IEEE, 2009.
Gabriele Röger and Malte Helmert. The more, the merrier: Combining heuristic estimators for satisficing planning, In Proceedings of the International Conference on Automated Planning and Scheduling, volume 20, pp. 246-249, 2010.
Vasanth Sarathy, Daniel Kasenberg, Shivam Goel, Jivko Sinapov, and Matthias Scheutz. Spotter: Extending symbolic planning operators through targeted reinforcement learning. arXiv preprint wrXiv:2012.13037, 2020.
Nikolay Savinov, Alexey Dosovitskiy, and Vladlen Koltun. Semi-parametric topological memory for navigation. arXiv preprint 1803.008 2018.
Tom Schaul, Daniel Horgan, Karol Gregor, and David Silver. Universal value function approximators. In International conference on machine learning, pp. 1312-1320. PMLR, 2015.
John Schulman, Yan Duan, Jonathan Ho, Alex Lee, Ibrahim Awwal, Henry Bradlow, Jia Pan, Sachin Patil, Ken Goldberg, and Pieter Abbeel. Motion planning with sequential convex optimization and convex collision checking, The International Journal of Robotics Research, 3319):255--1270, 2014.
John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.063477 2017.
Naman Shah, Jayesh Nagpal, Pulkit Verma, and Siddharth Srivastava. From Reals to Logic and Back: Inventing Symbolic Vocabularies, Actions and Models for Planning from Raw Data. arXiv preprint arXiv:2402. /1871, 2024. URL. https:::: / //axivi http://wwwwwwpppdd//////oo/ /24/2//24220 11871v2.
14

---

Tom Silver, Rohan Chitnis, Aidan Curtis, Joshua B Tenenbaum, Tomás Lozano- Pérez, and Leslie Pack Kaelbling. Planning with learned object importance in large problem instances using graph neural networks. In Proceedings of the AAAI conference artificial intelligence, 2021a.
Tom Silver, Rohan Chitnis, Joshua Tenenbaum, Leslie Pack Kaelbling, and Tomás Lozano-Pérez. Learning Symbolic Operators for Task and Motion Planning. In Proceedings of the IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pp. 3182-3189 2021b.
Tom Silver, Ashay Athalye, Joshua Tenenbaum, Tomás Peraan-PPérez and Leslie Pack Kaelbling. Learning Neuro-Symbolic Skills for Bilevel Planning. In Proceedings of the Conference Robot Learning (CoRL), 2022.
Tom Silver, Rohan Chitnis, Nishanth Kumar, Willie McClinton, Tomás Lozano-Pérez, Leslie Kael- bling, and Joshua B Tenenbaum. Predicate Invention for Bilevel Planning. In Proceedings of The AAAI Conference on Artificial Intelligence (AAAI), volume 37, pp. 12120-12129, 2023.
John Slaney and Sylvie Thiébaux. Blocks world revisited. Artificial Intelligence, 125(1-2):1194)) 19-153, 2001.
Siddharth Srivastava, Fugene Fang, Lorenzo Riano, Rohan Chitnis, Stuart Russell, and Pieter Abbeel. Combined task and motion planning through extensible planner-independent interface layer. 2014 IEEE international conference on robotics and automation (ICRA), pp. 639- 646. IEEE, 2014. URL https: http:://ppppeeeeeeee wwteecsbbeeelle www.bbrreeey....... wtw.elleedd/rrsssle//eeeee Scra14-planrob. pdf.
Richard S Sutton, Doina Precup, and Satinder Singh. Between mdps and semi-mdps: A framework for temporal abstraction reinforcement learning. Artificial intelligence, 112(1-2):
181-211, 1999 URL http:ttts//wwsccieeeeeee rect ctm/ ctlom/sciiee httm///ccennneeeeeeeeee///e S0C043702 000011111000011aaaaa1a0000222220 1-s2. 2=.2.00-0004457229900022222
pdf.
Mare Toussaint. Logio-geometric programming: An optimization approach to combined task and motion planning. In IJCAI, pp. 1930-1936, 2015.
Shivam Vats, Maxim Likhachev, and Oliver Kroemer. Efficient recovery learning using model
predictive meta-reasoning. 2023 IEEE International Conference on Robotics and Automation (ICRA), pp. 7258-7264. IEEE, 2023. URL https:://// htttps://ww... ri. cmu, edu/ http//apppppllaaoa 2023/03 submi s 200003////mm//mm ceessssoncammmaae ra rewdy.eaday.... .add.
Zi Wang, Caelan Reed Garrett, Leslie Pack Kaelbling, and Tomás Lozano-Péree Pérez. Learning composi- tional models of robot skills for task and motion planning. The International Journal of Robotics Research, 40(6-7):866-8%) 2021. URL https: //arii://axxv..../// http:/dd//00/00 0 444 pdf.
Fangkai Yang, Daoming Lyu, Bo I. Liu, and Steven Gustafson. Peorl: Integrating symbolic planning and hierarchical reinforcement learning for robust decision-making. arXiv preprint arXiv: 1804.07779, 2018.
Sung Wook Yoon, Alan Fern, and Robert Givan. Ff-replan: A baseline for probabilistic planning. In ICAPS, volume pp. 352-359, 2007.
Yan Zhang, Amirreza Razmjoo, and Sylvain Calinon. Leamndecoopoos:: Learning problem decom- position for efficient task and motion planning. arXiv preprini arXiv:2408.06844 2024.
Shaoting Zhu, Linzhan Mou, Derun Li, Baijun Ye, Runhan Huang, and Hang Zhao. Vr-robo: A real-to-sim-to-real framework for visual robot navigation and locomotion. IEEE Robotics and Automation Letters, 2025.
15

---

A APPROACH DETAILS
A. ABSTRACT PLANNING GRAPH
Following previous works (Li et al., 2025; Kumar et al., 2024), the abstract states 5 S are ground atoms induced from a set of predicates e E V. For example, the predicate On (?ol, ?o2) ) describes if an object is placed on top of another object. Each predicate is classifier over the low-level states, with grounding function that maps continuous state representations into discrete truth values. Every option A in the experimented environments equipped with a planning operator op" written in the Planning Definition Domain Language (PDDL). Specifically, op" (Var, Pre, Efft -ftf, where Var is tuple of object placeholders, and Pre, Efft, Eff S V, respectively preconditions, add effects, and delete effects, are each set of lifted predicates defined with variables in Var. Given an initial state Za E X. we first use the predicates L to obtain the abstract state sp. With the set of operators {op", a E A), we then build the abstract planning graph in two levels:
Top Level. We build the top level of the abstract planning graph using the predefined options, with no simulator required. Starting from abstract (200), we conduct breadth-first search (BFS) until the goal is reached by an abstract state. We expand from each node: (1) ground every operator in the planning domain with all possible combinations of the typed objects, (2) check if any operator's preconditions are satisfied by the current abstract state, and if yes, (3) for every such operator, apply its add and delete effects to obtain the next abstract state, and draw a directed edge to the new node.
At least one abstract state that satisfies the goal will be found after building the top level of the abstract planning graph, since we assume access to sufficiently robust TAMP options in obsly-bbee and deterministic environments. It is possible that more than one abstract state Us,,S, 8g in the existing graph satisfy the goal when BFS terminates. This means that they level of the graph, and the number of high-level steps for the corresponding plans are the same. We argue that SLAP has the advantage of exploring which Sy will benefit from the learned shortcuts the most. For example, in the Obstacle Tower environment, Pure Planning sometimes outputs plans where obstacle blocks are stacked on top of each other after being moved away from the target area. In contrast, SLAP consistently outputs plans with 8g as all obstacle blocks being scattered on the table, because it is only towards this sg that the most effective "slap" shortcut can be leveraged.
the same depth in the top
Bottom Level. Not all the nodes and edges in the top level can be reached in practice. For example, in the Cluttered Drawer environment, just by grounding the options, the graph includes an abstract state where the robot directly reaches a grasping position around the target object, but this is impossible in practice due to the clutter. To consolidate the abstract planning graph, we start the root node zo in the bottom level, conduct BFS to preserve only the feasible parts of the graph, and for each node record the set of low-level states reached by different incoming paths.
The shortest path is found in the bottom level for execution-time-tee miniemminiiizing solution. For this, we use a path-dependent adaption of Dijkstra's ' algorithm such that we can re-expand a node if the accumulated edge costs of a new path is lower. This new adaptation turns out to be only slightly more expensive than the original Dijkstra's 's algorithm. At evaluation, we stop expanding the more expensive branches when the shortest path goal has already been exposed. We argue that, compared to the number of low-level steps saved at execution, the computational overhead of planning with abstract planning graph augmented by shortcuts is minor. See Appendix D.2 for relevant results.
A.2 OBJECT SUBSTITUTION FOR SHORTCUT GENERALIZATION
To complement the description in Section 4.4, we provide pseudo-code for the object-substitttion mechanism used during SLAAP evaluation for shorteut generalization. Algorithm 3 checks whether a learned shortcut can be reused different number of new objects by searching for a type-preserving injective object mapping that preserves the shortcut's 's add/delete effects.
Our use of symbolic equivalence to guide object substitution is intentional: SLAP reuses shortcut policy whenever its expected symbolic add/del effects can be matched under a substitution. This design enables generalization of learned shorteuts different numbers of objects (Section 5.1), different goals (Appendix D.I,, and objects with -uitt--diittibution physical configurations (Section 5.1 & Appendix 1).) as long their symbolic effects align.
16

---

Algorithm 3: Object-Substittionn for Shortcut Generalization
Input:
Arainn deval
// two shortcut transitions
Output:
(success,
I/ Construct relevant atom sets
AtomS < (0di)) (
AtomSeval (Ovvl)) del(Geva)
// Feasibility checks: predicates and object types if ATTEASSIBLPRDDDICATTTAAAAOAO
AtomSeeal then
L return (Palse, ()
if INFEASIBLETYPES (AtomSS AtomS then
L return (False, 0)
// Search for type-preserving, injective substitution a t-9 0
Build candidate sets C(o) for each rel (elaan)))) from objects in rel(v))a) with matching type. for each o in a fixed ordering of rel do choose d' (o) satisfying:
(i) o' not already assigned i;
(ii) for every atom AtomSmain the atom obtained by substituting each object in according to a U fo + o'} also appears in AtomS
such d' exists then
L return (False, 0)
// early prune
+ a (or return (True, o)
B ENVIRONMENT AND EXPERIMENT DETAILS
In this section, we provide the detailed operators, options, and predicates for each environment, as well as experiment settings. For more details, please refer our open-sourced code.
Figure 7: Environment Visualization. From left right four environments featuring long horizons, sparse rewards, and various physical interactions: Obstacle 2D), Obstacle Tower, Cluttered Drawer, Cleanup Table.
Obstacle 2D:
Operators & Options: Pick, Place, PickFromTargeer and P PlaceInTarget.
Predicates: IsBlock (?o), IsSurface (?o), IsRobot (?o),
On (?ol, ?c2), Overlap (2o1, ?o2), Holding (?o1, ?o2),
GripperEmpty (?o), Clear (?o), IsTarget (?o), NotIsTarget (?o).
Task Description: There is 1-by-1 target area in the middle of the bottom line, the exact size of one block. The agent controls a gripper that can interact with the blocks. The goal of the task is place target block in the target area. The other scattered blocks are either
17

---

blocking the target area in their initial positions (i.e. obstacle blocks) somewhere else on the bottom line (i.e. irrelevant blocks). Therefore, in order to reach the goal, the agent would have to interact with the obstacle blocks to clear the target area. The initial positions of the blocks are randomized while guaranteeing that at least one of the blocks will partially block the target area make the task harder. During generalization test for different numher of objects, we add one additional block on the bottom line given the limited space.
Typical Shortcut from SLAP: Our algorithms learns a shortcut policy that "pushes" the obstacle in the target region while holding the target block.
Experiment Setup: We sample 10 tasks for this environment. For each sampled task, randomly roll out Nooloout = 1000 episodes, with Tolkout = 100 max steps per episode. In the random rollouts, we used threshold of Kullout = 1 to identify promising shortcuts. From all the tasks and episodes, SLAP found 11 shortcuts, with 40 scenarios in total. During training, implement PPO algorithm with batch size of 16, learning rate of 3e-4, and an entropy coefficient of 0.01 for each of the shortcut policy learning. The shortcut policies are trained for 1000 episodes with 50 maximum steps per episode to obtain the shortest output plans we have observed.
Obstacle Tower:
Operators & Options: Pick, Place, Stack, Unstack, PickFronTarget, PlaceInTarget.
Predicates: TsBl ockk (?o), IsSurface (?o), IsRobot (?0),
IsMovable (?o), Not Mot.aaMovalle (20), On (?o1, 7c2),
Nothingon (?o), , Holding (?o1, ?o2), NotHolding (?ol, ?02),
GripperEmpty (?o), IsTarget (?o), NotIsTarget (?o).
Task Description: This environment is 3D PyBullet adaptation of the Blocks2D environ- ment with more complexities. It has a table, Franka Emika Panda 7-DOF robot, and some lettered blocks on the table. A small area marked as target area on the table, and one of the blocks is marked with letter "T" to be the target block. As for the other blocks, some are stacked in the target area and blocking almost fully, while others are scattered elsewhere on the table. Similar to Blocks2D, the goal is to place block T in the target area, but this would require moving the other blocks away from the target area first. During generalization test for different number of objects, we adjust the number of stacked blocks in the target area and randomly scatter additional blocks on the table.
Typical Shortcut from SLAP: Our algorithm learned shortcut policy that "slaps" the block tower on the target region to make it clear. The policy can be instantiated after the target block is picked up.
We sample 10 tasks for this environment. For each sampled task, we randomly roll out Nrollout = 100 episodes, with Toolout = 300 max steps per episode. In the random rollouts, we used threshold of K 5 to identify promising shortcuts. From all the tasks and episodes. SLAP found 92 shortcuts, with 1070 scenarios in total. During training, we implement PPO algorithm with a batch size of 16, learning rate of 3e-4, and entropy coefficient of 0.01 for each of the shorteut policy learning. The shortcut policies are trained for 3000 episodes with 100 maximum steps per episode to obtain the shortest. output plans we have observed.
Experiment Setup:
Cluttered Drawer:
Operators & Options: Reach, GraspFrontBack, GraspLeftRight, GraspFullClear, GraspNonTarget, PlaceTarget, PlaceFrontBlock,
Predicates: IsBlock (?o), IsTable IsDrawer (?0), IsRobot (?o),
IsMovable (?o), NotIaMovable(2)) ReadyPick (?o),
NotReadyPick (?o), On (?ol, ?02), Holding (?o1, ?02),
NotHolding (Po1, ?o2), GripperEmpty (?o), IsTargetBlock (?o),
NotIsTargetBLock (?o), BlockingLeft (?o1, ?02),
Blocki BlockingRight (?o1, ?o2), BlockingFront (?o1, ?o2),
18

---

BlockingBack (?o1, ?o2), LeftClear (?o), RightClear (?o),
FrontClear (?o), BackClear (?o), HandReadyPick (?o).
Task Description: In this environment, a Franka Emika Panda 7-DOF robot aims to grasp target block inside a cluttered drawer and place it on the table. Initially, there are a number of obstacles that make the target block not graspable with given motion skills. Therefore, the abstract planner will try to reach, grasp, and place each of these obstacles to make at least two sides of the target block clear (graspable). During training, there are four obstacles blocking the right, left, front, and back sides of the target block, respectively. During generalization test for different number of objects, randomly scatter additional obstacles in the drawer.
Typical Shortcut from SLAP: Our algorithm learns to "wiggle" the robot hand around the target block with the fingers open. such that its sides become clear. This shortcut policy is used with the given skills during planning.
Experiment Setup: We sample 10 tasks for this environment. For each sampled task, randomly roll out Nrollou = 100 episodes, with T = 300 max steps per episode. In the random rollouts, we used a threshold of K 5 identify promising short cuts. From all the tasks and episodes, SLAP found 74 shortcuts, with 1012 scenarios in total. During training, we implement PPO algorithm with a batch size of 16, learning rate of 3e-4, and an entropy coefficient of 0.01 for each of the shortcut policy learning. The shorteut policies are trained for 1500 episodes with 100 maximum steps per episode to obtain the shortest output plans we have observed.
Cleanup Table:
Operators & Options: Reach, Grasp, Lift, Drop,
Predicates: IsBlock (?o), IsTable (?o), IsDrawer (?o), IsRobot (?o),
IsMovable (?o), NotIaMovable
ReadyPick (?6),
NotReadyPick (?o), On (?o1, ?o2), Holding (2o1, ?o2),
Not dithooldiigggg (?o1, ?o2), GripperEmpty (?o), HandReadyPick (?o),
AboveRverythimg (?o), NotaboveFveeythhin (?o).
Task Description: In this environment, a Franka Emika Panda 7-DOF robot aims move all the objects on the table to a storage bin. These objects include three toys (duck toy, dinosaur toy, and robot toy) and a small wiper. All of them have highly irregular and realistic mesh shapes imported from Objaverse Deitke et al. (2023). The abstract planner plans pick each irregular object up and drops it into the bin. The toys are randomly scattered on the table in each episode; at initial placements, spheres to compensate for mesh inaccuracies introduced by downscaling (to have realistic toy sizes relative to the robot). During generalization test for different number of objects, we randomly scatter fewer or more Objaverse toy objects on the table.
check collisions using slightly enlarged bounding
Typical Shortcut from SLAP: Our algorithm learns to picks up the small wiper tool first and slowly "sweeps" at a certain height and an appropriate direction such that all the toy objects are gathered into the storage bin at once without falling off the small table in the middle of the process. This shortcut policy is instantiated after the wiper is picked up.
We sample 10 tasks for this environment. For each sampled task, we randomly roll out Nioilour 100 episodes, with Tooloot 300 max steps per episode. In the random rollouts, we used a threshold of Kallnat = 5 to identify promising short cuts. From all the tasks and episodes, SL.A found 54 shorteuts, with 770 scenarios in total. During training, we implement PPO algorithm with batch size of 16, learning rate of 3e-4, and an entropy coefficient of 0.01 for each of the shortcut policy learning. The shorteut policies are trained for 3500 episodes with 100 maximum steps per episode to obtain the shortest output plans we have observed.
Experiment Setup:
The hyperparameters for RL shortcut learning are exactly the same for all the environments, since shorteut policies do not require any hyperparameter tuning. The hyperparameters Nrollout, Trollout: and Knilout for random rollouts pruming are consistent across all PyBulee environments but are adjusted for the Obstacle 2D environment for its significantly lower complexity.
19

---

B.1 ABLATIONS ON RANDOM ROLLOUTS PRUNING
For our experiments on the three PyBullet environments, we use a consistent set of hyperparameters for random rollouts pruning, with ratio of /
5/100 5% for selecting shorteuts to learn. Ablation results of this ratio are shown in Table 2. Useful shortcuts are pruned significantly when the threshold is around 20%. In general, this threshold provides mechanism to trade off training time and plan length.
Ratio K Kotlow/ / N mallow
Success Rate
Plan Length
5%
100%
0%
178.2
58.1
10%
100%
0%
167.0
46.1
15%
100% = 0%
185.0
54.4
20%
100% = 0%
209.0 79.1
25%
100% 0%
202.0 81.6
30%
100% = 0%
333.0 36.4
35%
100% = 0%
349.0 74.0
Table 2: Ablations on rallout /Nollout- We varied such ratio in the experiments Cluttered Drawer and report average performance over 3 random seeds.
Our random-rollou pruning mechanism is simple, but it is task-agnostic and generally applicable. It is also surprisingly effective: for example, in the Cluttered Drawer environment, 98.70% of all possible shortcuts are pruned. To further validate the technique, we conducted an additional experiment in Cluttered Drawer where there 5623 pruned shorteuts. We randomly selected 200 of the pruned shortcuts to train with RL on one seed. The overall shortcut training success rates are 3.64% 12.15%, with 9 of them successfully added evaluation time. The number of execution steps are comparable to that of Pure Planning, except in one evaluation episode where placing and lifting a non-target object are replaced by shortcut of dropping with "jittering" movement of the robot arm. Overall, these results confirm that these shortcuts can be pruned with little impact to test-time performance.
B.2 ABLATIONS ON SHORTCUT LEARNING POLICIES
In Section 4.2, argued that any continuous-state, continuous- RL algorithm serve the backbone for shortcut learning. To substantiate the claim, we present ablations on the Cleanup Table environment using three different backbone algorithms: proximal policy learning (PPO) (Schulman et al., 2017), soft actor-critic (SAC) (Haarnoja et al., 2018), or SAC with hindsight experience replay (SAC+HER) (Andrychowicz al., 2017).
Environment
Approach
Success Rate
Plan Length
Relative Path Length
SLAP (PPO)
100% + 0%
113.7 + 17.0
+ 74.55% + 4.5 %
SLAP (SAC)
100% = 0%
160.2 = 19.4
I 64.1% + 5.0%
Cleanup Table
SLAP (SAC+HER)
100% + 0%
131.0 19.5
$ 70.6% = 5.2%
Pure Planning
100% + 0%
446.3 + 34.9
0%
Table 3: Results of Different Shorteut RL Algorithms Cleanup Table. We report average performance over random seeds with standard deviations. Different RL algorithms eventually converge similar results shortcuts' execution-tine efficiency and overall plan lengths. We observe slightly better performance with PPO as the shortcut policy backbone, consistent with our choice for the main results reported in the paper.
20

---

Cleanup Table
900
SLAP (PPO)
(SAC)
400
SLAP (SAC+FTER)
Plan lengl (sleps)
Planning
300
300
Training Steps per Shortcul (x1000)
Figure 8: Training Dynamics of Different Shortcut RL Algorithms on Cleanup Table.
C BASELINES DETAILS
In this section, we describe the implementation details of all the baselines we have covered in the paper, including the baselines presented in the main results and the ablations used for shorteut policy learning analysis.
Pure Planning. Pure Planning uses the same abstract planner as SLAP but without any learned shortcuts or low-level policies. All actions are executed through predefined skills. The planner operates with the same planning horizon as SLAP to ensure fair comparison. This baseline represents the performance of planning approaches without learning components.
Pure RL (PPO). For the pure RL baseline using PPO, we train policies directly on the full task (xo.9) 9) with reward functions that penalize execution time through step penalties (and an optional positive bonus reward for achieving the goal). The PPO implementation uses batch size of 16, learning rate of 3e-4, 10 epochs, discount factor of 0.99, and entropy coefficient of 0.05. Compared to our approach SLAP, we spent more time tuning the hyperparameters of the pure RL baselines to ensure fairness. The reported hyperparameters is the setting where we observed a nonzero training success rate for Obstacle 2D environment (0.14% average training success rate). Training is conducted for 1, 1,000,000 total steps with episode lengths matching the environment-specife maximums. Network architectures consist of 2-layer MLPs with 64 hidden units per layer and tanh activations for both policy and value networks.
Pure RL (SAC+HER). Given the sparse reward nature of our environments, we implement baseline using Soft Actor-Critic with Hindsight Experience Replay. The SAC component uses learning rates of 3e-4 for actor, critic, and temperature networks, with a replay buffer size of 1,000,000, batch size of 16, and target smoothing coefficient of 0.005. The networks are 2-layer MLPs with 256 units per layer. HER is configured with a "future" goal selection strategy and replay ratio of 0.8. Training runs for 1,000.000 000,000 steps with initial exploration phase of 1000 episodes. The reward functions still consist of step penalties; the policies observe a non-negative (or an optional positive bonus reward) reward if they reach a state that is within distance of 0.01 compared the goal. This distance-checking is possible because the observations are object-centric, so we only need extract partial observations that are directly relevant the task goal.
Hierarchical RL (PPO). The hierarchical RL baseline outputs combined action vector of low- level controls and skill activations. able to complete the tasks in the Obstacle 2D environment after we increased the entropy coefficient to 0.05 for more exploration. However, it fails to solve any of the more complicated PyBullet tasks after we conducted systematic scans of hyperparameters. For the reported experimental results, use the same model architecture and hyperparameters the Pure RL (PPO) baseline: learning rate of 3e-4, batch size of 16, 10 epochs per update, discount factor of 0.99, and entropy coefficient of 0.05. Training runs for 1, 1,000,000 steps.
21

---

The original SOL algorithm jointly learns controller and option policies via the given intrinsic rewards. We made several modifications to the implementation and presented additional inputs to SOL to make our monghorizonn tasks easier for it to learn. First, our SOL assumes access to all the predefined skills grounded with different combinations of typed objects. When a predefined skill is chosen, it is executed until completion and can indicate early skill termination. If the controller calls a predefined skill whose preconditions are not satisfied by the current atoms, the skill outputs no-op actions and returns control to the meta-controller. This is the same during evaluation, we call the controller again instead of reporting errors on the infeasible operators selected in order to reduce task difficulty. Our SOL baseline also assumes access to the shorteut data from the abstract planning graphs to better leverage the hierarchical structure in the same way SLAP. The intrinsic rewards for shortcut policy learning SOL are also the same as SLAP goal-based sparse rewards upon shortcut completion. Furthermore, within the SOL algorithm, we removed the controller penalty: it is casy to select grounded skills with unsatisfied preconditions, and the accumulated penalties often overwhelm the sparse task completion signal and prevent learning. Training is conducted for 50,000,000 total steps with episode lengths twice the environmenn--specfee maximums, We use PPO with learning rate 3e-4, discount factor 0.995, GAE 0.98, exploration coefficient 0.01 (they used 0.0001 for PointMaze environments), with each skill option executing for up to 100 steps.
SOL.
The two baselines below only differ from SLAP in the RL architecture for learning shortcut policies:
Abstract Subgoals. This baseline directly augments the raw enviromment observations with a multi-hot encoding of the abstract terminal state of the corresponding shortcut, where each atom mapped to a fixed index the context vector. single shared PPO policy is trained across all shortcuts using these augmented observations. We use the same RL. hyperparameters for Abstract Subgoals as SLAP (see Appendix B).
Abstract HER. This baseline shares the same SAC hyperparameters the pure RL (SAC+HER) baseline described above. However, instead of sampling goals from training trajectories in the goal relabeling stage in standard HER, we use a custom NodeBase buffer that samples goals from our planning graph's 's abstract states. This is equivalent to training a coal-conditioned RL policy on multiple shortcuts, and we limit the pool we sample from to terminal abstract states of promising shortcuts. The goals, same as the abstract subgoals baseline, are represented as multi-hot encodings. The hyperparameters of Bodeeasss replay buffer differs from the Pure RL (SAC+HER) baseline with a smaller replay buffer size of 1000 and larger replay ratio of 0.95. These adjustments are made such that it learns all the promising shortcuts more equally at the same time.
D ADDITIONAL EXPERIMENTS
D.1 GENERALIZATION OVER GOALS
In Section 5.1, we have discussed SLAP's generalization capabilities to tasks with different numbers of objects. Here, we present additional results on SLAP's ability to generalize to new tasks with different goals. As mentioned in Section 4.3, generalization over goals is realized by leveraging the abstract planning graph; different goals correspond to different sets of nodes in the graph. To generalize task with new goal unseen during training, simply need to find the shortest path to one of the abstract states that satisfy the new goal.
In Figure 9, we see that on average SLAP finds shorter plans than Pure Planning for new tasks with different goals. The large standard deviations are due to the random sampling of abstract goals. An example is shown for the Obstacle Tower environment. The "slap" shorteut learned during training to achieve the goal of placing the target block in the target area. But in evaluation time, with new goal of stacking the blocks in reverse order, SLAA is able to use the same shortcut to slap all the blocks on table, and re-stack the blocks directly afterwards.
D.2 TIME EFFICIENCY
In this section, we include results on the time efficiency of SLAP at test time: How much compu- tational overhead does the abstract planning graph augmented with shorteuts introduce? In Table 1
22

---

Obstacle
Obstacle
Cluttered Drawer
Cleanup Table
250
Plan Langth (stape)
300
20
200
200
150
200
130
10-
100
100
100
50
50
SLAP
Pure Planning
SLAP
Fure Planning
SLAP
Pure Flanning
SLAP
Pare Flanning
Goal
Initial
Same Shortcut
on
Goal
B
(stacked
in
Figure 9: Generalization New Tasks. Results average plan lengths on 15 tasks with randomly sampled goals in evaluation for each environment. With a fixed set of trained shortcuts, SLAP finds shorter plans on average for these new tasks.
have shown the proportion of execution time save for the robot deployment. Here present realistic estimates on the overall time efficiency considering both planning time and execution time at real-world deployment.
Environment
Approach
Compute time during planning (seconds)
Execution sleps
Per-step execution time choose SLAP over Pure Planning (seconds)
SLAP (Ours)
15.2 1.2
73.8 + 4.3
Obstacle Tower
Any
Pure Planning
18.4
0.2
238.6 + 12.8
SLAP (Ours)
275.2 + 8.0
174.2 + 62.3
Cluttered Drawer
1.2
Pure Planning
65.5 5.2
349.4 68.1
SLAP (Ours)
201.0 3.9
113.7 = 17.0
Cleanup Table
0.5
Pure Planning
34.0
5.8
446.3 = 34.9
Table 4: Time efficiency. Comparative results of SLAP's and Pure Planning's planning time and execution steps at evaluation. While SLAP incurs slightly higher planning time than Pure Planning in Cluttered Drawer and Cleanup Table, the significant reduction in execution steps more than compensates for this cost under realistic per-step execution time.
In Table 4, we record the clock time of SLAP's planning phase evaluation on the three PyBullet environments that we have, as PyBullet (Coumans & Bai, 2016) simulates the robot-object interaction physics of our manipulation tasks well and provides reliable proxy for real-world deployment. Based on the compute time during planning and the number of execution steps SLAP improves compared to Pure Planning. we give lower bounds on the per-step execution time where the users would prefer SLAP over Pure Planning just for time efficiency reasons. In Obstacle Tower environment, we can see that SL.AP has lower planning time and execution steps evaluation, so SLAA is preferable for regardless of how long each execution step takes in reality. As for Cluttered Drawer and Cleanup Table environments, the lower bounds are 1.20 and 0.50 seconds respectively values that are within the typical range of per-step execution time for many real-world robots.
Note that we are not using any heuristics to accelerate graph search for SLAP, whereas Pure Planning the Fast-Forward heuristic (Hoffmann, 2001) with greedy cost-first search to reduce planning time. Heuristics can be integrated with graph search in SLAP to further boost its time efficiency, which actively working towards.
23

---

D.3 SLAP FOR ABSTRACT PLANNERS WITH SUBOPTIMAL ABSTRACTIONS
In SLAP. we define shortcuts based on the hierarchical structure of the abstract planning graph induced by the predefined skills. We made the assumption that these user-provided abstractions are sufficiently robust generate solutions for goals in our task distribution (see assumptions in Section 3) such that SLAP can be applied on top of the planners to further improve their execution time without losing completeness guarantees. However, for complicated real-world robotics problems the abstractions can be suboptimal. We are interested in such cases to see if SLAP's performance will degrade and to what extent.
We modify the Cluttered Drawer environment to test SLAP's performance when the grounding functions of predicates are noisy and imprecise. In particular, the Cluttered Drawer domain in- cludes several predicates (BlockingIeft (?o1, ?o2), BlockingRight (?o1, ?o2), , BlockingE ront (?o1, ?o2), BlockingBack (?o1, 202)) ) that reflect whether the robot can directly grasp the target object from the cluttered drawer without manipulating the sur- rounding objects first. The thresholds for such grounding functions are very important, and we add noises to the thresholds for the perceiver at every step mirror realistic scenarios where we are planning with perception and localization systems that have prediction errors.
In the original implementation, the "blocking" predicate is classified to be true in direction if the distance between the two objects in that direction is less than the width w of an object. For each set of the experiments below, define range for such threshold [cr w. C2 w] and randomly sample threshold for the grounding function at each step. At test time, to handle suboptimal abstractions at the abstract level, we replan each time step (following previous works like (Yoon et al., 2007)). For fair comparison, we extend Pure Planning to replan as well.
Environment
Approach
Success Rate
Plan Length
Relative Path Length
Cluttered Drawer SLAP (Ours)
0% 0%
500.0 + 0.0 (max)
N/A 0%
[w, 2w]
Pure Planning
63% + 9 %
403.5 : 77.5
Cluttered Drawer SLAP (Ours)
98% + 1 1%
195.6 56.0
45 % + 18%
[wo 1.5w]
Pure Planning
100 + 0%
358.3 + 52.4
0%
Cluttered Drawer SLAP (Ours)
100% + 0%
174.2 + 62.3
50% + 20%
(Optimal)
Pure Planning
100% + 0%
349.4 + 68.1
0%
Cluttered Drawer SLAP (Ours)
100% + 0%
168.0 + 45.2
J. 53% + 16%
(0.75u, w|
Pure Planning
100% + 0%
359.4 = 56.9
0%
Cluttered Drawer SLAP (Ours)
92% + 5 5%
204.7 + 72.1
J 55% + 17%
[0.5w, w]
Pure Planning
54% + 1 11%
449.8 = 32.1
0%
Table 5: Results on variants of Cluttered Drawer with suboptimal abstractions. We report average performance over 5 random seeds with standard deviations. Abstractions have to shift significantly from the "optimal" before SLAP's performance degrades in comparison to Pure Planning.
From Table 5, when the thresholds for grounding functions are sampled from [0.5w, w). SLAP applied on top of suboptimal abstractions even improves upon the success rates of Pure Planning. Some learned RI. shortcuts connect from noisy abstract states with misclassified "blocking" predicates to states that lead to the goal. In comparison, without the flexibility of RI., Pure Planning would replan and be completely misguided by the abstractions.
However, SLAP's performance degrades substantially when the suboptimal abstractions are too noisy. When the thresholds are sampled from [w, 2w], whether the target object is being blocked solely depends on the sampled threshold at the current step, since the probability that a surrounding object is moved to distance of 2w away from the target object is low. In this case, the abstract planning graph can no longer provide good structure to define helpful shortcuts for RL to learn. Therefore, SLAP's success rate goes to 0%.
24

---

D.4 SLAP IN STOCHASTIC, PARTIALLY OBSERVABLE ENVIRONMENTS
As mentioned in Section 3, we focus on applications to fully-observable and deterministic environ- ments, aligned with the scope of most TAMP methods (see survey Garrett et al. (2021)). However, we are also interested in SLAP's performance in environments with looser restrictions.
We first introduce a stochastic variant of the Obstacle Tower environment that features noisy actions (1% std Gaussian noise), object physics (random variations in 10% size, 20% mass and friction), stack alignment (1% position noise and 10% rotation noise of each block in the stack), and random dropping (with 1% probability if any object is held). We train shortcut policies with the same setup as in Section 5. At test time, we replan on each time step, same as Pure Planning. Results over 5 seeds are shown in Table 6. Similar to the main results in Table 1, SLAP outperforms Pure Planning and RL terms of plan length. Perhaps surprisingly, in this stochastic setting, SLAP also outperforms Pure Planning in terms of success rate. This is because the shortcuts learned with RL are better able to handle stochasticity than the user-provided options. Qualitatively, instead of relying solely on the held object to push the obstacle stack, the robot bends lower and uses its arm to push.
We also introduce a partially observable variant of Obstacle Tower where the top block of the obstacle stack is occluded and therefore absent from the simulator used for planning. We use pre-traine pre-trained policies to test generalizability and robustness and again use replanning at test time. The results in Table 6 show that Pure Planning consistently fails; qualitatively, it tries directly grasp the second block and gets stuck in collision. SLAP attains a 78% success rate (compared to 2% for Pure Planning) using "slap" shortcut that is similar to the object-based generalization results, but importantly, the planner and shortcut policy do not have knowledge of the occluded block.
Environment
Approach
Success Rate
Plan Length
Relative Path Length
SLAP (Ours)
92% + 4%
119.7 + 103.6
4 1.9%
+ +6%
Obstacle Tower
Pure Planning
84% + 6%
293.6 + 58.4
0%
(stochastic)
PPO SAC+HER
0% = 0%
500.0 = 0.0 (max)
N/A
0% = 0%
500.0 = 0.0 (max)
N/A
Hierarchical RL
0% = 0%
500.0 = 0.0 (max)
N/A
SLAP (Ours)
78% + 8%
178.0 + 182.0
1 64% + 37%
Obstacle Tower
Pure Planning
2% 2%
493.7 + 44.4
0%
(partially
PPO
0% + 0%
500.0 + 0.0 (max)
N/A
observable)
SAC+HER
0% 0%
500.0 + 0.0 (max)
N/A
Hierarchical RL
0% = 0%
500.0 = 0.0 (max)
N/A
Table Results on variants of Obstacle Tower with looser environment assumptions. We report average performance over 5 random seeds with standard deviations. The shortcuts learned with RL are better at handling stochasticity. And because shortcuts like "slap" involve the robot's 's interactions with multiple objects at once, the task success rates are much higher compare to Pure Planning when a subset of the objects is fully occluded.
D.5 SLAP UNDER OUT-OF-DISTTRBUTIOO PHIYSCCAL CONFIGURATIONS
In many robotic settings, the physical properties of objects test time (e.g., mass, friction, size, or contact noise) may differ from those seen during training. To evaluate SLAP's robustness under such out-of-distribution physical configurations, we compare: (i) SLAP trained on the standard, deterministic Obstacle Tower environment and evaluated under heavily perturbed physics, and (ii) SLAP trained directly on the perturbed environment.
Our perturbed configuration introduces noisy actions (2% Gaussian), random object physics (10% size variation, 30% mass/friction variation), stack alignment noise (1% position, 10% rotation), and random dropping (2% probability whenever object is held). These perturbations significantly affect multi-object interactions and present a challenging test of robustness.
These results show that SLAP's learned shortcuts exhibit strong robustness to out-of-distribution physical perturbations even without retraining, and that training directly on perturbed physics further improves performance. This provides guidance for practitioners: SLAP can generalize effectively
25

---

Environment
Approach
Success Rate
Plan Length
Relative Path Length
Obstacle Tower
SLAP (Ours)
78% + 9%
151.3 + 115,8
J 558 + 32%
(perturbed)
Pure Planning
65% = 10%
357.5 + 54.2
0%
Table 7: SLAP trained on deterministic physies. SLAP can handle such physical perturbations better than Pure Planning. Results are reported across 5 seeds.
Environment
Approach
Success Rate
Plan Length
Relative Path Length
Obstacle Tower SLAP (Ours)
86%
7%
133.4 + 98.2
4. 63%
26 %
(perturbed)
Pure Planning
65% + 10%
357.5 + 54.2
0%
Table 8: SLAP trained on perturbed physics. As expected, performance improves further, but even in this challenging setting SLAP still exhibits failures due to large perturbations.
across moderate changes in physical properties, but for significantly altered dynamics it may be beneficial to train set of shortcuts.
26


Reviews:
[{"review_id": "ScDvSP9YeO", "reviewer": "Reviewer_AFvJ", "summary": "This paper tackles long horizon decision making in robotics where classic task and motion planning relies on hand specified skills and often yields long satisficing plans. The authors propose Shortcut Learning for Abstract Planning, or SLAP, which automatically learns new low level options that act as shortcuts between abstract states in a planning graph induced by the existing skill library. The system builds a two level abstract planning graph, searches for shortest executions at the low level, then augments the graph with learned options trained through model free RL in self contained shortcut MDPs with step penalties and goal termination. A simple but effective pruning strategy screens shortcut candidates using random rollouts before launching PPO training. At test time, SLAP plans with both given skills and learned options, prunes failing edges online, and selects shorter plans via Dijkstra on the ground graph. To generalize beyond the training object set, SLAP projects observations onto relevant objects determined from add and delete atom sets and applies object substitution to reuse learned policies when object identities differ. This preserves the relational inductive bias of TAMP while enabling dynamic behaviors beyond fingertip grasp and place such as slap, wiggle, and wipe.", "questions": "- How many shortcut policies were ultimately trained and kept per environment during the runs reported in Table 1, and what was the total wall clock training time per environment including pruning and PPO updates?\n- What termination condition is used for each learned option at test time beyond the abstract state check and step limit. Do you implement safety guards such as maximum end effector velocity or minimum clearance during dynamic actions like a slap or wipe?\n- You evaluate separate PPO policies per shortcut pair. How do results compare to a single goal conditioned policy trained across shortcut goals when both are tuned equally, and how does data efficiency change as the number of abstract states grows?\n- The object substitution criterion checks add and delete inclusions. How is the mapping computed in practice when multiple candidates exist, and what is its computational cost during planning on the larger PyBullet graphs?\n- For hierarchical RL, did you try curriculum learning, intrinsic motivation, or hindsight relabeling at the high level to mitigate sparse rewards before concluding failure on the three PyBullet domains?", "limitations": "", "rating": 8, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "Framing and practical value\n- Clear problem statement that existing TAMP systems rely on hand designed skills which limits efficiency and expressivity. SLAP focuses squarely on reducing execution time without discarding the benefits of abstraction and search.\n- Elegant algorithmic design that keeps planning and learning modular. The abstract planning graph yields a well defined search problem, and shortcuts are learned in parallel MDPs with simple goal conditions and dense step penalties.\n- Relational generalization via relevant object projection and object substitution is well motivated and effective, letting the same shortcut policy apply across object sets and counts.\n\nEmpirical evidence\n- Consistent improvements in plan length across four diverse domains with long horizons and sparse rewards. Reductions are large in magnitude, for example about 69 percent in Obstacle Tower and over 50 percent in the PyBullet tasks.\n- Clear wins over strong baselines representing three regimes: pure planning, pure RL with PPO and SAC plus HER, and hierarchical RL with access to the same predefined skills.\n- Training steps analysis and shortcut discovery counts show monotonic gains as more shortcuts are learned, connecting learning progress to planning improvements.\n- Generalization experiments demonstrate robustness to different numbers of obstacles and to additional distractor objects. The learned dynamic behaviors like slap and wipe act on multiple objects and keep plan lengths stable.", "weaknesses": "Assumptions and scope\n- Relies on a known transition function and fully observable deterministic settings for graph construction, although variants relax these assumptions. Real systems often face sensing delays, latency, and controller noise which may require tighter integration of failure recovery and uncertainty aware planning.\n- Assumes the provided option set enables task completion. When this is not true, completeness can be lost. Appendix results discuss such cases but a stronger treatment of failure detection and fallback would help.\n\nScalability and compute\n- The number of candidate shortcuts scales with the square of the number of abstract states. The pruning heuristic is simple and effective but a learned prioritizer or search over the shortcut space could further reduce training cost. Wall clock budgets and GPU hours per environment would make the compute footprint transparent.\n- Planning time modestly increases compared to pure planning in two domains before being outweighed by shorter execution. A more thorough analysis of search heuristics and graph size versus latency would help practitioners choose configurations.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "JrcZhlF6Cm", "reviewer": "Reviewer_bFSp", "summary": "This paper proposes an approach to facilitate Task and Motion Planning efficiency (in term of plan length) by learning additional options to get across abstract states using RL. Compared to simply using a set of limited options (e.g., move the block tower one by one), the proposed method enriches the set of options and opens the possibility of reaching goal states with few steps (e.g., push down the tower entirely).", "questions": "When conducting random rollout pruning, what is the action space, atom action or provided options?", "limitations": "", "rating": 6, "confidence": 4, "soundness": 3, "presentation": 3, "contribution": 2, "strengths": "The paper is well written and easy to read, especially Fig 1 provides a good illustration of desired shortcuts and Fig 3 gives a clear overview of the method.\n\nTechnically, the proposed method to generalize over objects / object numbers, to the best of my knowledge, provides an interesting and novel way for downstream adaptation.\n\nAdditionally, the experiment results strongly support the proposed method, where it outperforms vanilla TAMP and hierachical RL methods.", "weaknesses": "My major question is around the novelty of the proposed method. There are many skill learning methods where people learn skills by specifying a goal state (and optionally a start state) with RL, and then apply such learned skills to downstream planning or HRL. If I understand correctly, the proposed method is very similar to those methods, except that the start and goal states come from the planning graph. Is that right? Any novelty I missed? \n\nMeanwhile, I wonder what if the learned shortcut has non-zero failure rates, will SLAP still adopts such options? If so, what if the RL learned options fail will lead to an unrecoverable state, will the planning take such possibility into account?", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "8A7YGdls86", "reviewer": "Reviewer_aDVn", "summary": "This paper proposes SLAP (Shortcut Learning for Abstract Planning), a method that integrates model-free reinforcement learning (RL) with task and motion planning (TAMP) to automatically discover shortcut policies between abstract states. The main idea is to augment a symbolic planning graph with additional edges learned via RL. Each shortcut policy is trained to transition directly between two abstract states which effectively bypasses multiple intermediate actions and reduces plan length.", "questions": "In addition to the remarks made for the Weaknesses section, here are some additional questions:\n\n- In the pruning phase, a shortcut is only retained for RL training if random rollouts reach the terminal abstract state s_{\\text{term}} in at least K_{\\text{rollout}} / N_{\\text{rollout}} (which is \\approx 5% with the mentioned parameters) of attempts. Given that this requires non-negligible random success (especially for a 3-D environment) between abstract states, how are such reachable abstract-state pairs obtained? Is there any mechanism during the construction of the abstract planning graphs or the definition of abstract states that biases the graph toward physically close or feasible state pairs, making this 5 % success rate attainable? Because, even for the simplest 3-D tasks, having more than a 5% success rate by taking random actions is highly unlikely. \n\n- My understanding is that Figure 4 shows how, as training progresses, more shortcut policies become reliable and therefore less likely to be excluded from use during inference. In other words, the number of shortcuts that remain usable in the evaluation graph increases as RL training improves their success rates. Is this interpretation correct? The current wording (“increasing the number of training steps leads to more shortcuts being successfully learned and incorporated as graph edges”) is somewhat unclear because the number of learned shortcuts does not change with training.\n\n- “To create an initial state distribution, we do not assume that we can sample directly from sinit; instead, we sample from the states encountered in the abstract planning graphs for the training tasks.” I suppose the graph creation process is deterministic. So, doesn’t this limit the diversity of the initial state distribution? How robust is SLAP to out-of-distribution physical configurations at test time, and could additional randomization during graph construction improve generalization?", "limitations": "", "rating": 2, "confidence": 4, "soundness": 2, "presentation": 2, "contribution": 1, "strengths": "- The intuition of the paper (discovering shortcut connections in an abstract planning graph) is conceptually sound and easy to grasp. It is a simple yet effective idea that directly addresses the inefficiency of long hierarchical plans in TAMP frameworks.\n\n- The approach can produce genuinely new high-level actions that are not part of the manually defined option set (e.g., slap). This demonstrates the potential of the method to extend the agent’s action set beyond what is explicitly encoded by human designers.\n\n- The paper is clearly written and well-structured, making the overall framework and experiments easy to follow.\n\n- Long horizon is one of the reasons why RL does not work effectively. Solving small RL problems with short horizons makes sense.", "weaknesses": "A primary weakness of this work lies in its conceptual alignment with the TAMP paradigm and the choice of experimental baselines.\n\n1. Conceptual Dissonance with TAMP: The core philosophy of TAMP is to find plans that are valid with respect to a given symbolic model, ensuring that high-level action sequences are grounded and physically feasible according to predefined rules. The proposed method, SLAP, learns \"shortcut\" policies (e.g., \"slapping\" a tower) that achieve a goal state by operating outside of this symbolic structure. While this can yield more efficient plans, it fundamentally reframes the problem from one of constrained, symbolic planning to one of unconstrained trajectory optimization. This raises the question of whether SLAP is improving upon a TAMP solution or solving a different, less constrained problem altogether. The potential for emergent, \"destructive,\" or unpredictable behaviors is at odds with the safety and predictability that motivates the use of TAMP in the first place.\n\n2. Inadequate Baselines: The comparison to model-free RL baselines is not particularly insightful. It is well-established that vanilla RL algorithms struggle with the long-horizon, sparse-reward problems that TAMP is designed to solve. Since SLAP heavily leverages the strong structural priors from the TAMP framework (the abstract graph and initial options), outperforming these baselines is an expected outcome and does not sufficiently isolate the contribution of the shortcut-learning mechanism itself.\n\nIn summary, the paper positions itself as a hybrid TAMP-RL method, yet it diverges from the core principles of TAMP and compares against RL methods on a task setup where they are known to be inefficient. A clearer articulation of its contribution, perhaps as a method for discovering new symbolic operators rather than just bypassing them, and a comparison against more relevant baselines would significantly strengthen the paper.\n\nBelow are some further remarks:\n- The methodology depends on finding two abstract states where there is at least a success rate of K_{rollout}/N_{rollout} transitioning from one to another state by taking random actions. I find this very restrictive and dependent on the abstract planning graph generation.\n\n- The paper lacks a clear and fair baseline. It does not make sense to use pure RL algorithms as baselines for such complex, long-horizon tasks that fundamentally require high-level task planning. Even in simpler motion-planning problems, RL methods typically demand more training steps than the 500k used here to achieve meaningful performance. Since SLAP is built on a TAMP framework with strong structural priors, comparisons to model-free RL is not ideal. That’s why it cannot be claimed that the proposed method increases the performance. The paper already includes a comparison with the no-shortcut case. But this is more of an ablation study rather than a baseline. Finally, reporting success rates over only 10 trials per task is insufficient for statistical reliability; larger-scale evaluations or confidence intervals are needed to support the claimed improvements.\n\n- The core idea of using RL to learn shortcut policies between abstract states is not a significant conceptual contribution. The method essentially applies standard model-free RL within a predefined TAMP structure to learn transitions that skip multiple existing options. While this integration is practically useful, it does not introduce new algorithmic insights or theoretical advances in either reinforcement learning or task and motion planning. The contribution is therefore more of an engineering combination of known components than a novel methodological development.\n\n- The notation in Section 4.4 is not intuitive. add(â) and del(â) denote sets of atoms, whereas rel(â) denotes a set of objects involved in those atoms. The subsequent use of expressions such as add(â_train)[σ(rel(â_train))] ⊆ add(â_eval) is confusing (the square-bracket substitution notation is unconventional and not clearly defined). I can understand what is meant but a more rigorous and transparent mathematical formulation (or pseudocode) of the object substitution process would significantly improve clarity.\n\n- The paper claims that learned shortcut policies can be reused on new objects through an object-substitution mapping σ, which aligns the add/del atom sets after substitution. However, the method for finding σ is not clearly described. When multiple objects are involved, determining consistent multi-object mappings becomes nontrivial, yet the paper provides no explanation of how σ is computed, whether it must be one-to-one, or how ambiguities are resolved. This lack of detail makes it difficult to evaluate the reliability and scalability of the object substitution mechanism proposed in Section 4.4.\n\n- Figure 4 is hard to read. I would create two figures: one with graphs, one showing a learned shortcut (and improve this image).\n\n- The analysis for Q5 (“Which RL design decisions are important for learning shortcuts?”) is limited in scope. The section “Shortcut Policy Learning Analysis” examines only one factor (whether shortcut policies are trained independently or as a shared universal policy). Other key RL design aspects (e.g., algorithm choice, reward shaping, exploration strategy) are not explored. As a result, the section provides a partial answer to Q5 and does not fully justify the general phrasing of the question.\n\n- The claimed generalization ability of SLAP is limited. Section 4.2 describes “generalization over objects,” but the mechanism is a simple object-substitution procedure based on symbolic equivalence of add/del atoms. This allows policy reuse only when new tasks are structurally isomorphic to training ones. The method does not learn to generalize over varying object geometries, dynamics, or unseen relational structures (its transfer is purely symbolic). Consequently, the generalization claim overstates the scope of what the approach can handle.\n\n- The abstract claims that SLAP “consistently outperforms planning and RL baselines”. As Table 1 demonstrates, SLAP matches the Pure Planning baseline in success rate (100%) and only improves efficiency by reducing plan length. The improvement therefore lies in shorter trajectories, not higher task success.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "EUvfyj6oZ8", "reviewer": "Reviewer_sKAL", "summary": "This paper introduces Shortcut Learning for Abstract Planning (SLAP), a novel framework that enhances robotic problem-solving by synergizing traditional Task and Motion Planning (TAMP) with Reinforcement Learning (RL). Addressing the limitation that TAMP relies on pre-programmed and often inefficient skills, SLAP autonomously discovers more effective behaviors by analyzing the high-level structure of an abstract plan to identify potential \"shortcuts.\" It then uses RL to train new, dynamic, low-level skills (such as \"slapping\" or \"wiping\" obstacles) to bridge these gaps in the plan. These learned shortcut policies are integrated back into the planner, enabling it to find significantly shorter and more efficient solutions. The key contributions are a dramatic reduction in plan length by over 50%, a high success rate on complex, long-horizon tasks where pure RL methods fail, and strong generalization to new tasks and objects not seen during training.", "questions": "Questions/suggestions are included in the \"Weaknesses\" section. I am very open to raising my score if my concerns are addressed", "limitations": "", "rating": 4, "confidence": 3, "soundness": 2, "presentation": 3, "contribution": 2, "strengths": "- Figure 1 is very well made and clear\n- The explanation of how the work fits into the existing literature is very good, even for someone unfamiliar with the relevant literature\n- The results seem pretty amazing in terms of improvement over baselines", "weaknesses": "- Figure 2 and 3 are pretty confusing in my opinion and it is not clear just from looking at the figure what the grey and black balls are supposed to represesent -- this should be made clearer so that it is understandable just from looking at the figure\n- Some analysis of sample/computational efficiency should be provided in the main text and results (how many extra samples, how much extra computation, how much extra training time is required to learn these shortcuts). There may be an appendix related to this but I believe at least a summary should be included in the main text so that the reader can know if potentially this improvement in performance is just from giving extra data to the learning algorithm through the shortcut learning policies \n- Some discussion of how this algorithm might be used when there is not access to a simulator (or if it just not possible in that case) should also be included, or what additional pieces would be needed in the case of no simulator\n- I am unsure of the novelty of the approach. It seems like SLAP is just a way to choose which option policies to learn during training? The relationship/difference to previous work on hierarchical RL should be made clearer in the Related Work or Introduction section", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)