Proceedings of the International Symposium on Combinatorial Search
Heuristic search and combinatorial optimization are currently very active areas of research. For example, researchers investigate how to search in real-time, how to search with limited (possibly external) memory, how to solve sequences of similar search problems faster than with isolated searches, how to improve the runtime of the searches over time, how to trade-off between the runtime and memory consumption of the search and the resulting solution quality, and how to focus the searches with sophisticated heuristics such as pattern databases. Their results are published in different conferences such as IJCAI, AAAI, ICAPS, NIPS, ICRA, and IROS. The International Symposium on Combinatorial Search (SoCS) is meant to bring these researchers together to exchange their ideas and cross-fertilize the field. Thus, in addition to seeking separate answers to questions like how to design more accurate memory-based heuristics, more I/O-efficient disk-based search algorithms, or more efficient clause-learning strategies, the symposium will stimulate thoughts on combining various techniques originated from different areas of search.
Lifelong LaCAM with Local Guidance for Lifelong MAPF
Local guidance has recently proven to be a powerful driver of empirical performance in real-time, suboptimal multi-agent pathfinding (MAPF), improving the scalable configuration-based solver LaCAM. By injecting informative spatiotemporal cues around each agent, local guidance mitigates congestion, reduces waiting, and remains scalable enough even with tight time budgets, yielding state-of-the-art performance for one-shot MAPF. This study asks whether the same benefits can be lifted to the lifelong setting (LMAPF), where tasks arrive continuously and improvements in per-step plans can increase task completion throughput over long horizons. We propose LLLG, a Lifelong version of LaCAM enhanced with Local Guidance, which employs a receding-horizon windowed planning framework and warm-starts guidance from the previous solution at each timestep. Our method scales effectively, maintains high throughput even in compact, dense environments, and surpasses existing planners, thereby pushing the frontier of real-time, lifelong MAPF.
Copyright (c) 2026 Association for the Advancement of Artificial Intelligence
Fast and Scalable Rule-Based Search for Deadline-Constrained Anonymous Multi-Agent Path Finding
Anonymous Multi-Agent Path Finding (AMAPF) requires coordinating a set of interchangeable agents to reach a set of target locations. In the variant with Individual Deadlines (AMAPFwID), each target must be reached before a specified time limit. Although AMAPFwID is solvable in polynomial time, state-of-the-art approaches rely on max-flow computations over time-expanded networks, whose size grows quadratically with the workspace. This makes them computationally impractical for large-scale instances involving thousands of agents. We introduce DART (Deadline-Aware Rapid Target-swapping), a highly scalable rule-based framework for AMAPFwID. The method decomposes the problem into two integrated phases: (1) a Task Assignment Phase, using either Bottleneck Assignment with Cost Refinement (BACR) or Deadline-Aware Assignment with Conflict Refinement (DACR) to produce initial pairings; and (2) a Reactive Search Phase, which employs seven deterministic motion rules to resolve local spatio-temporal conflicts. A key component of the approach is an Excess Time heuristic that prioritizes agents based on their temporal slack, guiding the search toward deadline-feasible configurations. We provide a theoretical analysis of correctness and test DART on standard MAPF benchmarks. The results show that DART scales to maps with thousands of agents, reducing runtime by several orders of magnitude compared to the optimal solver while maintaining near-optimal solution quality (around 1.01 times the optimal sum-of-moves).
ID-PaS+: Identity-Aware Predict-and-Search for Solving General Mixed-Integer Linear Programs
Mixed-Integer Linear Programs (MIPs) are powerful and flexible tools for modeling a wide range of real-world combinatorial optimization problems. Predict-and-Search methods operate by using a predictive model to estimate promising variable assignments and then guiding a search procedure toward high-quality solutions. Recent research has demonstrated that incorporating machine learning (ML) into the Predict-and-Search framework significantly enhances its performance. Still, it is restricted to binary-only problems and overlooks the presence of fixed variables structure that commonly arise in real-world settings. This work extends the current Predict-and-Search (PaS) framework to parametric general MIPs and introduces ID-PaS+, an identity-aware learning framework that enables the ML model to handle heterogeneous variables more effectively. Experiments on several real-world large-scale problems demonstrate that ID-PaS+ consistently achieves superior performance compared to the state-of-the-art solver Gurobi and PaS.
Faster Grid Pathfinding with Approximate Bounding Boxes
Grid-based path planning is an important application used widely in computer games and robotics. One of the fastest current approaches to optimal grid-based path planning, JPS+BB+, relies on extensive pre-computation to compute, for each jump point node, pruning bounding boxes containing all points reachable optimally by leaving the node in each direction. With this, the search for a shortest path is almost direct, only rarely considering more than one leaving direction at each node. But the pre-computation is expensive, requiring a full Dijkstra search from each jump point node to every other node in the graph. For the largest grid maps, this may require over 8 hours. In this paper we explore how to speed up this pre-computation, at the expense of a decrease in the accuracy of the bounding boxes created. We show we can improve pre-computation time by up to two orders of magnitude while only increasing average search time by at most 60% but often less than 10%. The faster bounding box computation can also be used to compute bounding boxes for every node in the map, decreasing average search time by up to 20% with typically only a 10% increase in pre-processing time.
Symbolic Greedy Best-First Search with Operator-Potential Heuristics
Symbolic search has long been recognized as one of the state-of-the-art techniques for exhaustive state-space exploration and cost-optimal planning, leveraging compact state representations and efficient set-based operations. Despite its success in optimal planning, symbolic search has not traditionally been considered suitable for satisficing search, where heuristic guidance is paramount. In this paper, we investigate how to perform symbolic satisficing search aimed at efficiently finding good-quality solutions without guaranteeing optimality. We show that operator-potential heuristics are effective at guiding the search. Empirical results demonstrate that symbolic greedy best-first search with operator-potential heuristics is competitive with explicit state-space search.
Precomputing Multi-Agent Path Replanning Using Temporal Flexibility
Executing a multi-agent plan can be challenging when an agent is delayed, because this typically creates conflicts with other agents. So, we need to quickly find a new safe plan. Replanning only the delayed agent often does not yield an efficient plan, and sometimes cannot even yield a feasible one. On the other hand, replanning other agents may lead to a cascade of changes and delays, and it is computationally expensive. We show how to efficiently replan a single delayed agent by tracking and using the temporal flexibility of other agents while avoiding cascading delays. This flexibility is the maximum delay that the agent can take without changing the order with agents other than the initially delayed agent, or further delaying other agents. Our algorithm, FlexSIPP, precomputes all possible plans for the delayed agent and returns the changes to the other agents within the given scenario. We demonstrate our method in a real-world case study of replanning trains in the densely-used Dutch railway network and in the MovingAI MAPF benchmark set. Our experiments show that FlexSIPP provides effective solutions relevant to real-world adjustments, and within a reasonable timeframe.
From Projections to Cartesian Abstractions and Merge-and-Shrink: Comparing the Compactness of Abstraction Representations
The four major classes of state space abstractions in classical planning are projections, domain abstractions, Cartesian abstractions and merge-and-shrink abstractions. We study the representations for these classes through the lens of compactness: one class is at least as compact as another if it can represent all abstractions the other can represent with a polynomially bounded increase in representation size. We complete the picture of compactness relationships among the four classes of abstractions, in particular resolving an open question from the literature on the relative compactness of Cartesian abstractions and merge-and-shrink.
Beyond Static Assumptions: The Predictive Justified Perspective Model for Epistemic Planning
Epistemic Planning (EP) creates agents capable of reasoning about the nested beliefs of others. However, existing frameworks fundamentally rely on the ``static-environment'' assumption inherited from classical planning. This constraint limits their applicability in dynamic settings where variables evolve independently of agent actions (e.g., moving targets or falling objects). To relax this assumption, we introduce the Predictive Justified Perspective (PJP) model. Unlike previous models that assume unobserved variables remain the same (unless observed evidence suggests otherwise), PJP allows agents to use their history of observations to predict how variables change over time. We formally define this model and prove that it retains the computational efficiency of state-based planning while ensuring logically sound belief reasoning (satisfying the KD45 axioms). Experimental results on the Grapevine benchmark show that PJP successfully extends EP to dynamic environments, allowing agents to reason about nested beliefs regarding changing values—a capability absent in prior work.
ML-Guided Primal Heuristics for Mixed Binary Quadratic Programs
Mixed Binary Quadratic Programs (MBQPs) are an important and complex set of problems in combinatorial optimization. As solving large-scale combinatorial optimization problems is challenging, primal heuristics have been developed to quickly identify high-quality solutions within a short amount of time. Recently, a growing body of research has also used machine learning to accelerate solution methods for challenging combinatorial optimization problems. Despite the increasing popularity of these ML-guided methods, a large body of work has focused on Mixed-Integer Linear Programs (MILPs). MBQPs are challenging to solve due to the combinatorial complexity coupled with nonlinearities. This work proposes ML-guided primal heuristics for Mixed Binary Quadratic Programs (MBQPs) by adapting and extending existing work on ML-guided MILP solution prediction to MBQPs. We introduce a new neural network architecture for MBQP solution prediction and a new training data collection procedure. Moreover, we extend existing loss functions in solution prediction and propose to combine contrastive and weighted cross-entropy losses. We evaluate the methods on standard and real-world MBQP benchmarks and show that the developed ML-guided methods significantly outperform existing primal heuristics and state-of-the-art solvers. Furthermore, models trained with our proposed extension with combined losses outperform other ML-based methods adapted from MILPs and improve generalization in cross-regional inference on a real-world wind farm layout optimization problem.
Exact Number of Flips Required to Sort a Burnt Stack of Pancakes
In this work, we consider the burnt pancake problem, which is a well-studied problem going back to a work of Gates and Papadimitriou from 1979. The problem is to sort a stack of n one-sided burnt pancakes of different sizes, by a sequence of flips of the top pancakes, such that at the end of the flipping sequence the pancakes have increasing size and the burnt sides of all pancakes are face-down. The pancakes are denoted by 1, 2, ..., n, and a number is multiplied by -1, if the corresponding pancake has burnt side face-up. Let T(n) be the minimum number of flips to sort a special stack of n pancakes, namely [-1,-2,...,-n]. This instance has strong relevance because of its easy structure and as it has been shown to be a worst-case instance for several small n. Heydari and Sudborough gave in 1997 the currently best upper bound of T(n), namely (3n+3)/2 for n = 3 mod 4, which later has been shown to be exact by a work of Cibulka from 2011. Except these two works, no progress regarding lower and upper bounds has been made until now. In our work, we present that (3n+3)/2 is also an upper bound of T(n) for n = 1 mod 4, which again matches the lower bound of Cibulka in 2011 and thus is exact. Furthermore, we show that our construction approach for n = 1 mod 4 and the one of Heydari and Sudborough for n = 3 mod 4 cannot be applied for even n. However, as there might be different construction approaches, the case of even n remains an open problem, where two possible values for T(n) are possible, namely (3/2)n + 1 or (3/2)n + 2. Finally, we found two values, namely n = 24, n = 26, where the lower bound is attained.
Fast and Memory Efficient Multimodal Journey Planning with Delays
State-of-the-art multimodal journey-planning algorithms, such as ULTRA, have recently been adapted to account for delays. In this work, we extend this approach to be more memory-efficient, faster, and accurate. We also adapt this framework to other state-of-the-art algorithms, like CSA and RAPTOR. We demonstrate a speedup of x 1.9 -- 4.2 over existing algorithms in the single-criterion search. In the multicriteria setting, we achieve competitive speedup results but greater accurateness. We also found that our method scales much better as the delay increases.
Tree-MAPF: On the Complexity of Optimizing Multi Agent Path Finding on Tree Graphs
In its general form, Multi-Agent Path Finding (MAPF) is well known to be NP-hard for various optimization objectives. But determining the complexity boundary for restricted topologies remains a key theoretical challenge. This paper investigates the complexity of MAPF on tree topologies. While recent work has established that minimizing Makespan on trees is NP-hard, the complexity of other standard metrics has remained an open question. We prove that, even on trees, optimizing Fuel (total traveled distance) and the Sum of Costs each remain NP-hard, closing a significant theoretical gap. Conversely, we identify a polynomial-time solvable case: restricting the agents to their individual shortest paths and determining if a feasible solution exists by only adding wait actions, thus maintaining the optimal Fuel cost.
Alternating Target–Path Planning for Scalable Multi-Agent Coordination
The concurrent target assignment and pathfinding (TAPF) problem extends multi-agent pathfinding (MAPF) by asking planners to allocate distinct targets and collision-free paths to agents. Prior work on TAPF has relied exclusively on Conflict-Based Search (CBS), which tightly couples target assignment and pathfinding, resulting in compute-intensive, non-scalable solutions. In contrast, we propose an iterative refinement framework that decouples target assignment from pathfinding. Our framework builds on modern, fast, suboptimal MAPF solvers, such as LaCAM. Specifically, within a given time budget, it repeatedly solves MAPF for the current target assignment, identifies bottleneck agents via MAPF feedback, and refines the assignment. Empirical results show that this simple framework outperforms the state-of-the-art CBS-based solver in scalability; for example, the existing solver often fails to handle 50 agents, while our approach successfully scales to hundreds of agents while maintaining decent solution quality. This represents a solid step toward practical, large-scale TAPF suitable for real-world setups.
Maximizing Throughput in Lifelong Multi-Agent Path Finding with Unassigned Agents
The Multi-agent Path Finding with Unassigned Agents (MAPFUA) is a recently introduced practical variant of MAPF. In MAPFUA there are two types of agents: assigned agents that have targets to go to and unassigned agents}that do not have targets but are allowed to move to clear the way for the assigned agents. In this paper we deal with the lifelong variant LMAPFUA where new tasks arrive over time and the aim is to maximize the throughput. We first provide a new variant of Lacam for MAPFUA and a general framework for LMAPFUA. We then focus on the best balance between the total number of agents available and how many of them should be assigned for achieving high throughput. Our experiments show that usually a higher throughput is achieved if some assigned agents are transferred to be unassigned agents that may be better positioned to perform future tasks.
Minimizing Conditional Cost with Goal-Reachability Guarantee in Stochastic Shortest Paths with Dead-Ends
In several stochastic shortest path (SSP) planning domains, a planner must find a strategy to reach a goal in an uncertain environment in which some states are irrecoverable dead-ends. When dead-ends cannot always be avoided, the planner may face a tension between being safe and being efficient. Existing policy optimization criteria do not let the human operator control this trade-off directly: S3P imposes a strict priority on success probability before considering path cost, while fSSP relies on a failure penalty parameter whose tuning offers implicit control over the resulting trade-off. We introduce the Safety-constrained Conditional-Cost SSP (SCC-SSP), where the human operator chooses a minimum acceptable success probability and the planner minimizes the expected cost conditioned on reaching the goal. The ratio structure of this objective introduces a coupling between path costs and future goal reachability that places SCC-SSP outside the scope of standard Constrained Markov Decision Processes (C-MDPs). To resolve this coupling, we build an augmented MDP that tracks cumulative cost in the state, and prove that the optimal policy depends not only on the current state but also on the cost accumulated until the current state, with the optimum achieved by a mixture of at most two deterministic cost-dependent policies. This results in a class of policies strictly richer than stationary policies. To compute such policies, our algorithm combines Dinkelbach's method for fractional objectives with a Lagrangian relaxation of the safety constraint. Experiments on classical benchmarks indicate that SCC-SSP can trace the full Pareto front between success probability and conditional cost, whereas C-MDP produces operating points governed by the penalty parameter rather than the safety threshold.
Bidirectional Search for Longest Paths: Case for Front-to-Front Heuristics
Bidirectional heuristic search can potentially reduce search effort for problems amenable to backward search. Therein, it is well-known that front-to-front heuristics can reduce the number of node expansions, but their overhead is so high that overall runtime almost always increases. We propose BiXDFBnB, a bidirectional depth-first branch-and-bound algorithm that adapts the Single-Frontier Bidirectional Search (SFBDS) framework—originally developed for shortest-path (MIN) problems—to the Generalized Longest Simple Path (GLSP) setting. Because SFBDS inherently operates on paired states, front-to-front (F2F) heuristic evaluation arises naturally and avoids the overhead typically associated with bidirectional frontier management. We show that this adaptation can be successfully applied to maximization (MAX) problems while efficiently handling overlapping constraints. BiXDFBnB is applied to several types of longest-path problems: Longest Simple Path (LSP), Snakes, and Coil-in-the-Box (CIB). Empirical evaluation shows that the new algorithm frequently reduces the number of node expansions and, in some cases, also improves overall runtime.
GPU-Accelerated A* Search with Deep Neural Network Heuristics
Heuristic search is a foundational technique in artificial intelligence. Recent work has demonstrated that powerful heuristic functions represented as deep neural networks (DNNs) can be learned with machine learning. This combination of machine learning and heuristic search has been successfully applied to puzzle solving, quantum circuit synthesis, and chemical reaction mechanism pathfinding. This success has been accompanied by batched heuristic search algorithms, such as batch A* search, which take advantage of parallelism provided by graphics processing units (GPUs) for DNNs. However, the rest of the heuristic search algorithm remains on the central processing unit (CPU). This results in the often costly transfer of data from the CPU to the GPU for heuristic computation and leaves other GPU-based acceleration options unexplored. To address this, we investigate the benefit of performing heuristic search entirely on the GPU. Using the Rubik's Cube as our case study, we systematically profile the speedup achieved by each component of batch A* search when moved to the GPU. Our results show that GPU execution yields about 12.03× speedup over the CPU baseline that only uses the GPU for the heuristic function. These findings suggest that fully GPU-native heuristic search with DNNs is a practical and effective strategy for scaling learned heuristics to demanding combinatorial search tasks.
Thread-Ordered Parallel Greedy Best First Search
While parallelizing Greedy Best-First Search (GBFS) can accelerate planning, existing approaches offer no runtime guarantees: they are not necessarily faster than sequential GBFS, and counterintuitively, adding more threads can possibly degrade runtime. To address this unpredictable scaling, we introduce Thread-Ordered Parallel-GBFS (TOP-GBFS). Inspired by MonoBeam — which guarantees monotonically improving solution costs as beam width increases — TOPGBFS is a novel parallelization designed to ensure that search time never increases as thread count grows. Under standard assumptions, we prove that TOP-GBFS bounds the total number of expansions to a constant factor of sequential GBFS and guarantees monotonically non-increasing runtimes. We empirically validate this monotonicity and demonstrate that TOP-GBFS remains competitive with existing parallel GBFS implementations on standard PDDL benchmarks.
Learning, Commitment, and Completeness in Real-Time Heuristic Search
In real-time heuristic search, an agent must select its next action within a prespecified time bound. Amazingly, it has been possible to prove that, despite this myopia, certain real-time search algorithms are complete (guaranteed to eventually reach a goal) under a small set of assumptions. This hinges on the algorithms learning updated heuristic values. In order to elucidate the space of complete real-time algorithms, previous work has provided general algorithm frameworks, into which components that meet certain criteria can be plugged, and proved them complete. Recently, a cost-algebraic real-time framework was proposed that makes strong assumptions on its heuristic learning component but only weak assumptions on its action commitment component. In this paper, we show that the opposite is also possible: we present and prove complete an alternative framework that makes weaker assumptions about heuristic learning but stronger assumptions on action commitment. We demonstrate in the domain of Real-time SIPP how the new framework implies the completeness of previously-published algorithms This work expands our knowledge of the design space of complete real-time search algorithms.
Bridging Multi-Valued Heuristics and Dimensionality Reduction in Multi-Objective Search
Multi-objective shortest-path (MOSP) algorithms traditionally rely on single-valued heuristics (SVHs), which associate each state with a single admissible cost vector. While SVHs provide safe lower bounds, they fail to capture the trade-off structure of the Pareto frontier and often yield weak search guidance. Multi-valued heuristics (MVHs) address this limitation by mapping states to sets of cost estimates, enabling a richer approximation of possible trade-offs. Modern MOSP algorithms are highly dependent on dimensionality reduction (DR) techniques to efficiently perform dominance checks. However, integrating MVHs with DR introduces subtle correctness challenges. We show that naively combining DR with MVHs destroys the ordering invariants required for DR, leading to unsound and incomplete search. To address this issue, we develop the first theoretical frameworks for safely integrating MVHs with DR. First, we introduce NAMOA*dr-mvh, a theoretical baseline that restores search correctness by enforcing heuristic consistency. Recognizing the practical limitations of this approach, we then introduce our primary contribution, L-NAMOA*dr-mvh. This algorithm employs a "lazy," optimistic approach to DR, preserving exact correctness with only an admissible MVH by dynamically detecting and repairing local ordering violations. Across a range of benchmarks, L-NAMOA*dr-mvh matches or improves over state-of-the-art MOSP algorithms, and achieves speedups of over 10x in instances where the additional guidance provided by the MVH translates into stronger pruning.
Cooperative-ORCA*: Real-Time Proactive Deadlock Avoidance for Continuous-Space Multi-Agent Navigation
Multi-Agent Path Finding (MAPF) is a problem that requires computing collision-free paths for a set of agents from their start locations to designated goal locations. The problem has broad applications in domains where teams of robots must operate in a coordinated manner. ORCA* is a real time MAPF solver that assigns for each timestep a velocity for each agent. Due to its real time nature, it is myopic to future deadlocks that result from current decisions. ORCA*-MAPF attempts to remedy this limitation by introducing fallback mechanisms when deadlocks are detected. However, post hoc interventions often introduce significant flowtime overhead. In this paper, we introduce C-ORCA* and C-ORCA*-MAPF, continuous space MAPF algorithms that incorporate agents' entire spatial trajectory and their spatial dependencies to proactively prevent deadlocks from occurring, thus avoiding the high flowtime overhead associated with post hoc corrections in ORCA*-MAPF. The C-ORCA* family of algorithms significantly outperform previous state-of-the-art in terms of solve rate, runtime, and flowtime.
BCBS-AA: Bounded Sub-Optimal Conflict-Based Search for Multi-Agent Path Finding with Asynchronous Actions
Multi-Agent Path Finding (MAPF) seeks collision-free paths for multiple agents from their respective start locations to their respective goal locations while minimizing path costs. Many MAPF studies rely on a common assumption of synchronized actions, where the actions of all agents start at the same time and always take a time unit, which may limit the applicability of MAPF planners in practice. To bypass this assumption, various algorithms have been developed to handle asynchronous, non-unit-time actions, ranging from optimal to unbounded sub-optimal algorithms. This paper focuses on bounded sub-optimal algorithms for MAPF with asynchronous actions (MAPF-AA) due to their ability to balance solution quality and runtime efficiency. For MAPF, the recent bounded sub-optimal algorithms can intelligently distribute the sub-optimality bound among the agents based on agent-agent collision to achieve fast planning even with tight bounds. We find that directly adapting these techniques to MAPF-AA can degrade their performance due to asynchronous actions. This paper thus develops new techniques to consider asynchronous actions when distributing the sub-optimality bound among the agents and when selecting nodes for expansion during planning. Results show that our approach achieves up to 60% higher success rates and reduces the number of expansions during planning by up to an order of magnitude compared to existing methods.
Make Use of Your Search Effort: Data Augmentation for Learning Effective Planning Heuristics from Optimal Plans
Learning planning heuristics to guide search has proven to be an effective way to improve satisficing planning with data, while preserving the soundness and completeness guarantees of the planner. Prior work has shown that learning from optimal plans can yield more effective heuristics, since optimal plans provide high-quality supervision about promising search directions. However, generating training data is computationally expensive, as it requires solving challenging planning tasks optimally. We therefore propose search-free data augmentation methods that can substantially increase the size of training data from existing optimal plans and corresponding search traces, without solving any additional planning problems. In particular, we consider three complementary data augmentations with optimality guarantees on the augmented data: (i) Intermediate Goals, which converts subplans of an optimal plan into new optimal plans to alternative, intermediate goal states; (ii) Closed-List Trajectories, which leverages the fact that under A* with a consistent heuristic each expanded state is reached by an optimal path; and (iii) Partial-Order Plan, which samples multiple linearizations from the underlying POP, which are also optimal plans under state-independent action costs. Experiments on the IPC 2023 Learning Track demonstrate that our data augmentations significantly improve planning performance across many domains for two state-of-the-art frameworks, GOOSE (WLF+ranking) and Distincter (GNN+regression). For the first time, our data augmentation techniques enable GOOSE to surpass the coverage achieved by the first iteration of the LAMA planner.
A* is the most important algorithm in optimal heuristic search. For its implementation, details beyond the scope of textbook descriptions become relevant. One such detail is how A* deals with duplicate states. A common approach is to modify a state's open list entry when a cheaper path to that state is found, updating its key. A binary heap often serves as the underlying data structure despite its suboptimal asymptotic runtime. More complex structures with better asymptotic runtime such as Fibonacci heaps are said to not pay off. A wide-spread alternative is to delay duplicate detection until expansion, allowing multiple entries for the same state on the open list. So far, the effect of these choices has not been studied in isolation for domain-independent planning. We compare early duplicate detection using a binary heap, Fibonacci heap, pairing heap, or bucket priority queue to delayed duplicate detection in order to evaluate whether early duplicate detection can be worth it.
Parallelizing Classical Planning: Critical Path Heuristics on the GPU
Despite the tremendous capabilities of modern hardware in performing parallel computations, all major classical planners are limited to single-threaded execution on the CPU. We show how the critical path heuristic hm, commonly used in classical planning, can be parallelized and computed on a GPU. To that end, we construct a directed hypergraph, where nodes represent sets of atoms, associated with their reachability costs, and actions define weighted hyperedges. Iteratively performing convolutions on this hypergraph until a fixed point is reached allows us to efficiently compute hm on the GPU. Furthermore, it enables batching, so we can compute the heuristic in parallel for multiple states. Our approach naturally supports multiple cost functions, allowing efficient computation of cost partitioning for hm. We demonstrate experimentally that the GPU-based computation of hm can achieve speedups of several orders of magnitude over the traditional computation on a CPU.
Domain-Abstraction Heuristics for Simple Numeric Planning
Abstraction heuristics are among the most effective approaches in optimal classical planning. For numeric planning, however, existing abstraction heuristics suffer from the infiniteness of the abstract state spaces, which is an immediate consequence of numeric state variables. This has recently been analyzed for numeric Pattern Database (PDB) heuristics, which fall short of their classical-planning counterpart due to fundamental limitations in the handling of unbounded variable domains. In this work, we argue that domain abstractions offer a framework that lends itself much better to simple numeric planning, with abstract state spaces that are computed incrementally using counterexample-guided abstraction refinement (CEGAR), avoiding the exhaustive exploration of PDBs. We extend the established framework from classical planning such that the typically infinite concrete state space is fully represented in the abstraction, and adapt the CEGAR mechanism to support refining numeric abstractions. To obtain a strong search guidance, we combine multiple domain abstractions admissibly using the canonical heuristic. Our empirical evaluation exemplifies the potential of domain abstractions for numeric planning.
Bucket Aggregation in Bucket-Based Priority Queues for Heuristic Search
Bucket-based priority queues can reduce the overhead of priority queue operations for A* and related bounded-suboptimal and anytime variants, especially when transition costs are small integers. The buckets are usually indexed by both f-cost (primary) and h-cost (secondary), which enables efficient tie-breaking and priority ordering. However, when solution costs are large and the heuristic is informative, the number of secondary buckets within a primary bucket can become very large, leading to bucket sparsity that degrades performance. To address this, we introduce a simple aggregation method that restores bucket density while preserving standard solution-quality guarantees. We demonstrate its effectiveness in several benchmark domains.
Petri Net Induced Heuristic Search for Resource Constrained Scheduling
We formulate the Resource-Constrained Project Scheduling Problem (RCPSP) as optimal search over the reachability graph of a Timed Transition Petri Net with Resources, us- ing relative-delay tokens so that scheduling decisions cor- respond to transition firings in the induced state space. We solve the resulting problem with A∗ guided by a heuristic that combines Critical Path and resource-based lower bounds, and prove that it is consistent under our token-based time se- mantics. Experiments on the PSPLIB benchmarks show that the approach outperforms strong exact Mixed-Integer Linear Programming (MIP) baselines (SCIP, CBC) in both success rate and solve time. Per-instance analysis shows that heuris- tic search and MIP degrade along independent axes, resource tightness for A∗ and formulation size for MIP, with resource strength mediating which solver benefits from scale.
Formula Neural Networks as Action Policies in Safety-Critical Planning: An Empirical Evaluation
Formula neural networks (FNNs) are a recently proposed alternative to neural networks (NNs), with Boolean neuron values and hidden-layer nodes defined as propositional formulas over the previous layer. FNNs have been successfully applied to classification and, compared to standard NNs, offer greater interpretability. Here we show that they are also a promising alternative for learning action policies and that they can be more amenable to formal verification. We consider planning under uncertainty, with the objective to reach the goal while avoiding unsafe states. We adapt a recently proposed NN policy safety verification algorithm to FNNs. Our experiments show that, compared to NNs, FNNs can often learn competitive policies while being much faster to verify.
Embodying Multi-Hand Manipulation Policies by Searching the Assignment and Null Spaces
Learned manipulation policies increasingly predict motions for abstract “hands” and are attractive in practice because they rely on easily collected demonstrations and transfer across robot platforms. Executing these trajectories on multi-arm robots, however, is not trivial. Multi-hand policy outputs must be assigned to physical arms, each arm must realize a configuration-space motion that tracks its prescribed end-effector trajectory, and all arms must respect kinematic limits and avoid collisions. In the absence of algorithms that directly address this problem, practitioners typically extend single-arm inverse-kinematics (IK) pipelines in an ad hoc way, with no guarantees of feasibility or safety. In this work, we close this execution gap with a search-based framework that is theoretically complete for grounding policy-generated multi-hand trajectories onto physical multi-arm systems. Building on Conflict-Based Search, our method explicitly searches over both the discrete assignment of trajectories to arms and the continuous Jacobian null spaces of redundant manipulators, using redundancy to avoid inter-arm collisions while tracking the prescribed motions. This unified treatment of assignment and null-space motion yields a practically efficient planner that safely realizes coordinated manipulation-policy outputs on multi-arm robots. See omcbsa.github.io for more.
Front-to-Attractors: Modifying the Front-to-Front Heuristic in Bidirectional Search
Heuristics play a central role in the performance of bidirectional search algorithms, which commonly rely on two main classes. Front-to-end (F2E) heuristics estimate the distance from a state s to the target of the search (the goal for forward search or the start for backward search). In contrast, front-to-front (F2F) heuristics estimate the distance from s to the opposite search frontier using a pairwise function h(s, s'), where s' ranges over frontier states. Although F2F heuristics are typically more informative and therefore reduce the number of node expansions, their reliance on extensive pairwise evaluations incurs substantial computational overhead. To address this limitation, we introduce a new heuristic class, front-to-attractors (F2A), that preserves much of the informativeness of F2F while dramatically reducing its computational cost. Rather than evaluating distances to all states on the opposite frontier, F2A estimates the distance from s to a small, dynamically maintained set of attractors in the opposite search direction. These attractors serve as a surrogate for the full frontier, enabling rich heuristic guidance at a fraction of the computational expense while maintaining the optimality guarantees offered by F2F. We evaluate F2A across multiple domains and show that it reduces the number of pairwise evaluations by up to 11.2x compared to F2F, while achieving 4.8x fewer node expansions than F2E on average.
On the Use of AI Planning for Water Management of the Red River Basin in Vietnam
The management of reservoir-based hydrological systems is challenging due to complex dynamics and strong interdependencies. Traditional rule-based policies, derived from hydrological models, expert experience, and regulatory standards, are often too rigid, leading to inefficient use of water resources and limited ability to react to unexpected events such as off-season floods. We investigate how AI planning can support water management through the lens of numeric planning. The study focuses on the Hoa Binh reservoir, a key component of the Red River Basin in Vietnam, under hydrologically challenging dry-season conditions. Building on a previously validated PDDL-based simulator of the basin, we recast simulation inputs as planner-controlled release actions and study the resulting numeric planning task from a search perspective. The proposed formulation captures the complex system dynamics by defining actions that directly control the amount of water released on a daily basis. We first provide a fully domain-independent planning setting that makes no use of problem-specific information and observe that planners struggle to capture storage-dependent constraints, cumulative flows, and downstream interactions. Motivated by these limitations, we then integrate problem-specific structure and control knowledge into the domain-independent formulation to guide the planner toward higher-quality operating policies. Results indicate that planning can efficiently explore the decision space and generate plans of competitive quality compared to historical operation while achieving stricter adherence to operational constraints, particularly when enhanced with control knowledge.
Tree of Thoughts as a Classical Heuristic Search Problem: Formal Foundations and Design Patterns
Large Language Models (LLMs) have demonstrated remarkable reasoning capabilities, yet their standard generation process—auto-regressive token prediction—is inherently myopic and prone to cascading errors. To address this, the Tree-of-Thoughts (ToT) framework creates a search space over intermediate reasoning steps, allowing search models to explore, look ahead, and backtrack. However, current ToT research remains fragmented across Natural Language Processing and Automated Planning communities, often using inconsistent terminology and ad-hoc implementations. Consequently, we synthesize the ToT landscape through a unified taxonomy based on classical heuristic search terminology. We map LLM-based reasoning to classical search components: state representation (granularity of thoughts), successor generation (prompting operators), and heuristic evaluation (self-assessment of progress). We analyze existing work within the context of our taxonomy and identify emerging design patterns: systematic search (Best-First Search) for shallow, deterministic tasks and lookahead-heavy strategies (DFS, MCTS) for deep multi-step reasoning. We conclude by identifying open algorithmic challenges at the intersection of heuristic search and LLM reasoning, and call on the heuristic search community to engage with this emerging domain.
Evaluation of Baseline Methods for IDD-based SSD External Memory Search
Many difficult search problems can not be solved by algorithms such as A* using only RAM. Search algorithms which use external memory such as SSDs and HDDs with much higher capacity than RAM have been proposed in previous work, but previous work has focused on delayed duplicate detection approaches, as well as complex immediate duplicate detection (IDD) methods. Despite the ubiquity of SSDs, relatively simple methods for IDD have not been systematically studied. In addition, the effect of OS-level mechanisms for managing and speeding up accesses to external memory, such as page caches, has not been studied. This paper addresses these gaps in the literature by evaluating and analyzing the performance of simple baseline approaches to IDD-based A*.
Understanding Reward Shaping in Planning: A Theoretical and Empirical Analysis
Reward design is a critical yet often underexplored component of reinforcement learning for planning problems. In this work we analyze how different reward shaping strategies affect learning performance when using Proximal Policy Optimization (PPO). We evaluate several reward formulations derived from the objective function while keeping the learning algorithm and model architecture fixed. Experiments on benchmarks from the International Planning Competition 2023 show that commonly used shaping strategies do not consistently outperform sparse rewards. While some formulations provide competitive performance, our results highlight the difficulty of designing effective reward signals for policy gradient methods in planning domains.
COL-Trees: Efficient Hierarchical Object Search in Road Networks (Extended Abstract)
COL-Trees are a state-of-the-art data structure for hierarchical object search in road network graphs. While initially developed with multi-agent scenarios in mind, we show COL-Trees are highly suitable for single-agent queries as well, in particular, supporting upper-bound based k Farthest Neighbor search for the first time. Along with reducing pre-processing costs, we strengthen the case that COL-Trees are a highly versatile data structure with potential application to other problems by the combinatorial search community. To support such exploration, we also present a highly-optimized COL-Tree implementation as open-source for the first time.
The Pathfinding Benchmark (Extended Abstract)
Pathfinding problems are found throughout chemistry, mathematics, robotics, and computing. We present the Pathfinding Benchmark (PB), a work-in-progress benchmark of diverse and challenging pathfinding problems to evaluate the ability of state-of-the-art pathfinding algorithms and inspire new pathfinding algorithms. PB contains pathfinding problems from chemical reaction mechanism pathfinding, quantum circuit synthesis, theorem proving, multi-agent pathfinding, and combinatorial puzzles. Furthermore, PB pushes the boundaries of what should be posed as a pathfinding problem by posing language modeling, image generation, and training neural networks as pathfinding problems.
Adaptive Width Best-First Search: Dynamic Frontier Expansion for GNN-based Heuristics (Extended Abstract)
In this paper, we introduce Adaptive Width Best-First Search (AWBFS), a search algorithm designed to better exploit batched heuristic evaluation while preserving the guidance of Greedy Best-First Search (GBFS) when using learning-based heuristics on GPU architectures. The method targets domains in which learned heuristics are effective, but standard GBFS can stagnate on heuristic plateaus, a situation that is common in numeric planning. AWBFS addresses this issue by dynamically adjusting the number of frontier nodes expanded at each step. Starting from standard GBFS behavior, the algorithm increases the expansion width when no improvement in heuristic value is observed. For the use with learning-based heuristics, AWBFS tracks GPU memory usage to ensure it never exceeds the input limit. Experimental results show that AWBFS yields better performance than standard GBFS when paired with GNN-based heuristics.
Scalable Robust Multi-Agent Path Finding (Student Abstract)
Multi-Agent Path Finding (MAPF) algorithms face significant scaling challenges when extended to robust variants like k-Robust MAPF (kRMAPF), where agents may experience execution delays. While optimal solvers like kRCBS struggle to scale to larger problem instances, this work introduces kRLaCAM*, an adaptation of the eventually optimal anytime solver LaCAM* for robust environments. We propose a novelty called Cardinality Reduction (CR), which dynamically prunes conflicting actions from the low-level search and configuration generator based on the agents' recent history. Our preliminary empirical results demonstrate that kRLaCAM*-CR dramatically improves scalability, achieving a 100% success rate on dense benchmarks where state-of-the-art optimal robust solvers fail, while maintaining a reasonable solution cost.
Situated Planning with Soft Goals (Extended Abstract)
Situated planning addresses the case in which an agent needs to achieve goals in a dynamic world where opportunities may be fleeting, and thus planning time must be taken into account during the planning process. For example, planning to take a bus must be completed in time to get to the bus stop. Previous work has focused on maximizing the probability of finding a plan that is still feasible at the time planning completes. In this paper, we consider the more realistic case in which each goal is optional and carries a reward. This setting, known as planning with soft goals, is challenging because every state is a goal state, and a heuristic estimate of the distance to go should consider many possible combinations of achievable goals. Furthermore, in our situated setting, the planner should take into account the estimated feasibility of actually finding a plan for a goal set in time. Unlike previous work on situated planning, where the planner can stop when it finds a feasible plan, the planner may be better off continuing to search for a better plan. In addition, the planner must also decide when to commit to one of the plans it has discovered. We present a metareasoning approach based on computing multiple temporal relaxed planning graphs and estimating the expected utility of searching for a better plan. This work extends the use of automated planning to the all-too-common case in which one has too much to do and not enough time to do it.
Multi-Agent Path Finding with Unassigned Agents (MAPFUA) (Extended Abstract)
In the Multi-Agent Path Finding (MAPF) problem, the aim is to find collision-free paths for multiple agents. MAPF has many practical applications and has spawned massive research interest in the past two decades. Most MAPF research assumed that every agent is assigned a target it must reach. This assumption often does not hold in several key applications, such as automated warehouses and parking lots, where some agents are assigned targets to reach, and others, denoted as unassigned agents, can either stay idle or move to clear the way for the assigned agents. In this paper, we introduce this important problem, explain its uniqueness, and encourage the entire community to work on it.
LaCAM* Variants for Minimizing Makespan in Multi-Agent Path Finding (Extended Abstract)
Multi-Agent Path Finding (MAPF) requires conflict-free paths. Optimal MAPF solutions often minimize the sum of the costs of the paths (SOC), or their maximum (makespan, MKS). LaCAM* is a recent anytime MAPF solver, eventually converging to the optimal solution. However, LaCAM* was reported to have a considerably slow convergence speed to the optimum. Although this is true for SOC, in this paper, we show that LaCAM* can quickly find optimal MKS solutions. Additionally, currently, due to its anytime nature, LaCAM* uses a branch-and-bound search mechanism. We introduce a version of LaCAM* that uses IDA* and show that it has superb performance for finding optimal MKS solutions, even with thousands of agents. We explain all these phenomena.
Verification and Automated Construction of Social Laws for MAPF (Student Abstract)
Multi-Agent Pathfinding is the problem of collision-free navigation of agents to their destinations. Social Laws for MAPF are a decentralized framework for MAPF, where predefined laws (ordered rules) are used to avoid collisions. This work defines the key properties of such laws and proposes verification procedures, which are necessary for automatic construction of the laws.
MOSAIC: Skill-Centric Manipulation Planning with Physics Simulation (Extended Abstract)
Planning long-horizon manipulation motions using a set of predefined skills is a central challenge in robotics; solving it efficiently could enable general-purpose robots to tackle novel tasks by flexibly composing generic skills. Solutions to this problem lie in an infinitely vast space of parameterized skill sequences -- a space where common incremental methods struggle to find sequences that have non-obvious intermediate steps. Some approaches reason over lower-dimensional, symbolic spaces, which are more tractable to explore but may be brittle and are laborious to construct. In this work, we introduce MOSAIC, a skill-centric, multi-directional planning approach that targets these challenges by reasoning about which skills to employ and where they are most likely to succeed, by utilizing physics simulation to estimate skill execution outcomes. Specifically, MOSAIC employs two complementary skill families: Generators, which identify ``islands of competence'' where skills are demonstrably effective, and Connectors, which link these skill-trajectories by solving boundary value problems. By focusing planning efforts on regions of high competence, MOSAIC efficiently discovers physically-grounded solutions. We demonstrate its efficacy on complex long-horizon problems in both simulation and the real world, using a diverse set of skills including generative diffusion models, motion planning algorithms, and manipulation-specific models. Visit skill-mosaic.github.io for demonstrations.
Parallel Heuristic Search as Inference for Actor-Critic Reinforcement Learning Models (Extended Abstract)
Actor-critic models are a class of model-free deep reinforcement learning (RL) algorithms that have demonstrated effectiveness across various robot learning tasks. While considerable research has focused on improving training stability and data sampling efficiency, most deployment strategies have remained relatively simplistic, typically relying on direct actor policy rollouts. In contrast, we propose PACHS (Parallel Actor-Critic Heuristic Search), an efficient parallel best-first search algorithm for inference that leverages both components of the actor-critic architecture: the actor network generates actions, while the critic network provides cost-to-go estimates to guide the search. Two levels of parallelism are employed within the search---actions and cost-to-go estimates are generated in batches by the actor and critic networks respectively, and graph expansion is distributed across multiple threads. We demonstrate the effectiveness of our approach in robotic manipulation tasks, including collision-free motion planning and contact-rich interactions such as non-prehensile pushing. Visit https://p-achs.github.io for demonstrations and examples.
Policy-Guided Search on Tree-of-Thoughts for Efficient Problem Solving with Bounded Language Model Queries (Extended Abstract)
Recent studies explored integrating search algorithms with Language Models (LMs) to perform look-ahead on the "Tree-of-Thoughts" (ToT), improving performance on problem-solving tasks. However, these search algorithms overlook the computational costs of LM inference under constrained budgets. We adapt Levin Tree Search (LTS) (Orseau et al. 2018) to ToT (Yao et al. 2023), leveraging LM probabilities as a policy to guide tree exploration without additional evaluation queries. We extend theoretical results of LTS by showing that, for ToT (a pruned tree), LTS guarantees a bound on states expanded and thoughts generated. Empirical evaluation under fixed LM query budgets demonstrates that LTS consistently achieves comparable or higher accuracy than baseline search algorithms across three domains (Blocksworld, PrOntoQA, Array Sorting) and four distinct LMs.
Modelling Multi-Agent Pathfinding Problems by Integrating Connectivity and No-Collision Constraints (Extended Abstract)
Multi-agent pathfinding (MAPF) is the problem of finding collision-free paths for a set of agents in a shared environment, typically represented as a graph. One of the approaches to solving MAPF is based on representing the problem as a Boolean satisfiability problem. However, this method can produce extremely large Boolean formulas, both in terms of variables and clauses. The primary reason for the excessive number of clauses is the encoding required to represent the valid paths. In this paper, we propose two encodings of the MAPF problem designed for SAT Modulo Theories solvers. Our approach delegates all the valid path reasoning to a monotonic theory supporting source-target connectivity. This is then combined with a 2-SAT Boolean formula to prevent collisions between agents. Together, these components create an effective separation of concerns: the SAT solver focuses on resolving conflicts, while the theory solver handles the connectivity constraints. Our experiments are conducted in both makespan and sum of costs optimisation settings, empirically demonstrating a notable reduction in both the size of the MAPF encoding and the time required to generate it. In addition, when fixing the SAT solver across experiments, results demonstrate considerable performance improvements when transitioning from pure SAT to our proposed SMT encodings.
Ghost Agents in SAT-based Models for Multi-Agent Pathfinding (Extended Abstract)
Multi-agent pathfinding (MAPF) is the task of navigating a set of mobile agents in a shared environment while avoiding collisions when multiple agents occupy the same space simultaneously. One popular approach to solving MAPF is to transform the problem into a different formalism, such as Boolean satisfiability (SAT), and solve the problem using an off-the-shelf SAT solver. The current state-of-the-art SAT-based MAPF solvers model the position of each agent at each timestep as a Boolean variable and enforce valid movement and coordination via constraints among those variables encoded as a logical formula. It might be expected that the formula encodes a single valid, collision-free path for each agent, meaning that at any given time, each agent occupies exactly one location. In this paper, we explore the possibility of an agent being present at multiple locations simultaneously. While such relaxed encoding exists in the literature, the presence of duplicate agents is not discussed. In this paper, we coin the term ghost agents and show that their presence does not hinder the validity of the solution. As the relaxed encoding reduces the size of the formula, we compare it empirically. Furthermore, we compare empirically all approaches used in reduction-based MAPF solving and their combinations: single and ghost agents, with eager and lazy encodings of conflicts under both the makespan and the sum-of-costs objectives. The experiments show that no combination is a clear winner in all types of instances.