---
title: 'Many-RRT*: Multi-Tree Motion Planning'
url: https://www.emergentmind.com/topics/many-rrt
type: topic
---

# Many-RRT*: Multi-Tree Motion Planning

Searching arXiv for recent and related papers on Many-RRT* and multi-tree RRT* planning.
arxiv_search(query="Many-RRT* serial manipulators multi-tree RRT* inverse kinematics", max_results=5, sort_by="submittedDate")

arxiv_search(query="Many-RRT* serial manipulators inverse kinematics", max_results=10)

Searching arXiv for "Many-RRT*" and related multi-tree RRT* planners.

Many-RRT* denotes a multi-tree extension of RRT*-Connect for joint-space motion planning of serial manipulators when the terminal objective is specified in task space rather than configuration space. In its explicit 2026 formulation, the algorithm generates multiple inverse-kinematics solutions for a single end-effector pose and grows independent goal-rooted trees from those joint configurations in parallel with a single start tree, thereby avoiding premature commitment to a single inverse-kinematics branch [2603.04547]. More broadly, the term also points to a family of RRT*-style planning strategies in which multiple roots, forests, or destination-rooted trees are maintained concurrently in order to improve coverage, connectivity, replanning speed, or multi-goal performance [2106.03407][2205.14853].

## 1. Joint-space planning problem and the motivation for many trees

Many-RRT* is motivated by a structural mismatch between task-space goals and joint-space planning for high degree-of-freedom serial manipulators. The motion-planning problem is posed in joint space \(\mathcal{Q}\), with collision-free subset \(\mathcal{C}_\text{free}\subseteq \mathcal{Q}\), start configuration \(q_0\in\mathcal{C}_\text{free}\), and a goal pose \(g\in\mathcal{X}\) specified in task space through forward kinematics
\[
x = f(q), \quad f : \mathcal{Q} \to \mathcal{X}.
\]
A continuous joint-space trajectory \(\mathbf{q} : [0,1] \to \mathcal{Q}\) must satisfy
\[
\begin{split}
\mathbf{q}(0) &= q_0 \\
\mathbf{q}(1) &= q_N \\
\forall t \in [0,1],\quad \mathbf{q}(t) &\in \mathcal{C}_\text{free}
\end{split}
\tag{1}
\]
and is represented as a waypoint-based, piecewise-linear joint-space path
\[
\begin{aligned}
\forall i \in \{0,\dots,N\},\quad &\mathbf{q}(t_i) = q_i \\
\forall t \in [t_i, t_{i+1}],\quad &
\mathbf{q}(t) = q_i + \frac{t - t_i}{t_{i+1} - t_i}(q_{i+1} - q_i) \\
\text{s.t. }\quad &t_0 = 0,\quad t_N = 1 .
\end{aligned}
\tag{2}
\]
The associated optimal motion-planning problem is
\[
\mathbf{q}^\star = \mathop{\arg\min}\limits_{\mathbf{q} \in \mathbf{Q}} J(\mathbf{q}).
\tag{3}
\]

The central difficulty is that forward kinematics is non-invertible and highly nonlinear. A single task-space pose \(g\) generally corresponds to many joint-space states,
\[
\mathcal{Q}_g = \{q \in \mathcal{Q} \mid g = f(q)\},
\]
and for redundant manipulators the preimage \(\mathcal{Q}_g\) is typically a continuous manifold of dimension \(m-\dim(\mathcal{X})\). Even for non-redundant arms, multiple discrete inverse-kinematics branches are common. Because different \(q_N\in\mathcal{Q}_g\) can induce very different optimal path costs or even different reachability classes, standard single-goal planners such as RRT, RRT*, and RRT*-Connect are only asymptotically optimal conditional on the chosen terminal configuration, not over the full set \(\mathcal{Q}_g\) [2603.04547].

This leads to the reformulated optimization problem
\[
\begin{aligned}
\mathbf{q}^\star &= \mathop{\arg\min}\limits_{\mathbf{q} \in \mathbf{Q}} J(\mathbf{q}) \\
\text{s.t.}\quad \mathbf{q}(0) &= q_0 \\
\mathbf{q}(1) &\in \mathcal{Q}_g \\
\forall t \in [0,1],\quad \mathbf{q}(t) &\in \mathcal{C}_\text{free},
\end{aligned}
\tag{4}
\]
in which the terminal joint configuration is itself a decision variable [2603.04547]. Many-RRT* addresses precisely this one-to-many planning problem.

## 2. Parallel multi-goal tree architecture

The defining architectural move in Many-RRT* is to replace a single goal tree with a bank of goal trees. The planner maintains one start tree \(G^{N+1}\) rooted at \(q_0\) and multiple goal trees \(\{G^0,G^1,\dots,G^N\}\), each rooted at a different inverse-kinematics solution \(q'_i\) for the same task-space goal pose [2603.04547]. Each goal tree is advanced by standard RRT* operations—sampling, extension, and rewiring—while the start tree grows toward both random configurations and the regions newly explored by the goal trees.

The high-level procedure is:
1. sample multiple inverse-kinematics goals for the task-space target,
2. initialize one tree at each goal configuration and one start tree,
3. iterate standard RRT* updates on each goal tree in parallel,
4. extend the start tree,
5. attempt tree-to-tree connection when the current start-tree sample lies in a goal tree,
6. rewire the start tree and retain the lowest-cost connected trajectory found so far [2603.04547].

The start-tree sampling rule is explicitly mixed:
\[
v_i \sim
\begin{cases}
U\left[\mathcal{C}_\text{free}\right] & \gamma > \gamma_0 \\
U\left[\{q^{\prime}_k\}_{0}^N \cup \displaystyle\bigcup_{k=0}^N \{E_i^k - E_{0:i-1}^k\}\right] & \text{else}
\end{cases}
\tag{5}
\]
where \(\gamma \sim U[0,1]\). With probability \(\Pr[\gamma>\gamma_0]\), the start tree performs pure exploration in \(\mathcal{C}_\text{free}\); otherwise it samples from the set of IK roots and the newly added portions of the goal trees. This couples global exploration to opportunistic exploitation of promising goal-side structure [2603.04547].

This organization differs from standard bidirectional RRT*-Connect in a specific way: there is still a single start tree, but the goal side is no longer a single tree anchored to one chosen joint configuration. Instead, computational effort is distributed across multiple candidate terminal states. In the reported experiments, the implementation uses 10 IK solutions, yielding 10 goal trees plus 1 start tree [2603.04547].

## 3. Inverse kinematics, seeding, and the multi-armed bandit interpretation

Many-RRT* operationalizes the multiplicity of terminal configurations through an optimization-based IK pipeline. The inverse-kinematics subproblem is written as
\[
\begin{split}
\min\limits_{q} \quad &E(q) = \frac{1}{2} \|f(q) - x\|^2_W + \frac{1}{2} \lambda \| q - q^\prime \|^2 \\
\text{s.t.}\quad & q_\text{min} \le q \le q_\text{max},
\end{split}
\tag{7}
\]
with gradient
\[
\nabla E(q) = \nabla f(q)^T W \left(f(q) - x\right) + \lambda\left(q - q^\prime\right).
\]
Because this optimization is highly nonconvex, different seeds \(q^\prime\) lead to different local minima, i.e., different IK solutions [2603.04547].

To generate those seeds efficiently, the method first samples a large set \(M\) of collision-free joint states offline, computes their task-space images \(x=f(q)\), and stores pairs \((x,q)\) in a KD-tree keyed in task space. At query time, the planner retrieves the \(K\) nearest neighbors of the desired goal pose in that KD-tree and runs the IK optimization from each retrieved seed. The resulting candidate IK solutions are then downsampled to remove near-duplicates by discarding any pair with \(\|q_i-q_k\|\le \epsilon\), with \(\epsilon=10^{-4}\) in the reported experiments [2603.04547].

The paper interprets this setting as a multi-arm bandit problem: each IK solution is an arm, and choosing a single goal configuration commits all planning effort to that branch without prior knowledge of its feasibility or final path cost [2603.04547]. Many-RRT* does not resolve this through an explicit bandit allocation rule; instead, it runs the arms in parallel. This suggests a robust allocation strategy: every IK branch receives dedicated search effort, and the planner defers commitment until actual path costs become available.

The same one-to-many structure appears in other multi-goal RRT* systems, although in different domains. IMOMD-RRT* grows one RRT* tree per destination on a large graph and constructs an evolving distance matrix between destination-rooted trees before solving a relaxed TSP [2205.14853]. SFF* likewise starts a separate tree at each target and maintains a forest with virtual inter-tree edges for multi-goal path planning among obstacles [2106.03407]. These systems are not inverse-kinematics planners, but they share the same principle of postponing route commitment by maintaining multiple destination-rooted search structures.

## 4. Theoretical properties and computational profile

Many-RRT* inherits asymptotic optimality for each fixed start–goal pair from RRT*-Connect because each tree uses standard RRT* extension and rewiring. Conditioned on a specific inverse-kinematics solution \(q_i^\prime\), the corresponding start–goal planning process remains asymptotically optimal in the usual RRT* sense [2603.04547]. The paper’s stronger claim is that, as the number of sampled IK goals increases, the method transitions from locally asymptotically optimal to globally optimal with respect to the task-space goal, because it optimizes jointly over path and terminal configuration within \(\mathcal{Q}_g\) [2603.04547].

The planner also retains probabilistic completeness in the practical sense that, if a feasible path exists to any sampled IK solution, the probability of discovering one rises with the number of iterations. Its advantage over single-goal RRT* is therefore not only lower cost but reduced risk of complete failure due to an unfavorable IK choice [2603.04547].

From a computational standpoint, the paper distinguishes between the cost of per-tree RRT* updates and the cost of cross-tree connection. With \(m=N+1\) trees and \(n\) nodes per tree, naive extension and rewiring scale like \(O(mn\log n)\), but because goal trees are advanced in parallel, the wall-clock cost can approach \(O(n\log n)\) if sufficient processors are available. The connection routine \(\text{CONN\_TREE}\) is the dominant worst-case term, with \(O(mn^2)\) complexity [2603.04547]. The implementation is explicitly multi-threaded on CPU and is described as trivially extendable to GPU or NPU execution [2603.04547].

A plausible implication is that Many-RRT* is best viewed as a parallel search-allocation method rather than a purely algorithmic replacement for single-tree RRT*. In simple scenes, the added tree bank may offer only moderate gains; in cluttered scenes with many disconnected or high-cost IK branches, the parallel structure changes the qualitative success regime.

## 5. Broader many-tree RRT* landscape

The literature uses multiple, partly overlapping formulations of many-tree RRT* planning. Some works use the term directly; others instantiate the same structural idea without the exact name.

| Paper | Tree organization | Primary setting |
|---|---|---|
| Many-RRT* [2603.04547] | One start tree plus multiple IK-goal trees | Serial manipulators, task-space goal to joint-space planning |
| SFF* [2106.03407] | One tree per target plus virtual inter-tree edges | Multi-goal path planning with TSP post-processing |
| IMOMD-RRT* [2205.14853] | One tree per destination, grown multi-directionally | Multi-destination routing on large graphs |
| MA-RRT* [1302.2828] | Single joint-state RRT* tree | Centralized cooperative pathfinding |
| SI-RRT* systems [2404.01752] | Many single-robot RRT* instances coordinated by PP or CBS | Continuous-space multi-robot path planning |

These papers expose several distinct meanings of “many” in RRT*.

First, “many” can mean many terminal configurations for one task-space objective. That is the exact meaning in Many-RRT* for manipulators, where the multiplicity arises from \(\mathcal{Q}_g\) [2603.04547].

Second, “many” can mean many physical goals or destinations. SFF* constructs a forest with one tree rooted at each target and adds virtual edges rather than merging trees, so that multiple target-to-target alternatives remain available for subsequent TSP optimization [2106.03407]. IMOMD-RRT* similarly grows one tree per destination and uses connection nodes to build a reduced destination graph whose edge costs are repeatedly refined before a relaxed TSP is solved [2205.14853].

Third, “many” can mean many agents. MA-RRT* applies RRT* in the joint state space of all agents, maintaining one centralized tree whose nodes are joint configurations \((w_1,\dots,w_n)\) and whose edges are joint actions [1302.2828]. By contrast, Safe Interval RRT* avoids joint-space explosion by using many single-robot SI-RRT* planners as low-level solvers inside prioritized planning or conflict-based search [2404.01752]. In that hierarchy, “many-RRT*” is realized as a coordinated family of single-robot optimal planners rather than a single monolithic multi-robot tree.

Related non-RRT* forests also clarify the design space. MRRT keeps all valid subtrees after edge pruning in dynamic environments and regrows the resulting forest simultaneously, emphasizing tree reuse under replanning [2104.11059]. MA-RRdT* uses multiple root trees and shared disjointed trees to improve exploration efficiency for multi-robot path planning [2308.01533]. These are not Many-RRT* in the strict asymptotically optimal sense, but they reinforce the same structural principle: preserving and exploiting multiple search frontiers is often preferable to collapsing the search into a single representative tree.

## 6. Empirical behavior, applications, and limitations

The exact Many-RRT* algorithm was evaluated on a 6-DoF UR10e and a 7-DoF Franka Panda across four obstacle environments: Table, Wall, Passage, and Random [2603.04547]. In the hardest reported case—the 6-DoF Random environment—RRT* achieved a 1.4% success rate, RRT*-Connect achieved 1.6%, and Many-RRT* achieved 100.0%, with median first-solution iteration 225, median first cost 16.57, median final cost 12.97, first runtime about 42 ms, and final runtime about 570 ms [2603.04547]. Across robot morphologies and obstacle settings, the paper reports 44.5% lower cost in the same runtime and a significantly higher success rate, with 100% versus the next best of 1.6% in the hardest setting [2603.04547].

The results indicate that the largest benefits arise when inverse-kinematics branches are heterogenous in feasibility or cost. In Wall and Table, all methods succeeded, but Many-RRT* still produced the lowest median final costs. In Passage and Random, where the configuration space is effectively partitioned or cluttered, the multi-goal formulation shifted the success profile decisively [2603.04547].

This broader pattern is consistent with the multi-goal and multi-destination literature. SFF* showed that multiple RRT*-like trees with repeated inter-tree connections yield shorter target-to-target paths and lower final TSP costs than Multi-T-RRT and Lazy-TSP-style baselines [2106.03407]. IMOMD-RRT* demonstrated that multi-tree destination-rooted RRT* expansion can produce initial multi-objective routes faster and with far less memory than Bi-A* and ANA* on million-node road graphs [2205.14853]. Safe Interval RRT* systems showed that using many single-robot RRT* instances inside prioritized planning or CBS scales to tens or hundreds of robots while preserving higher path quality than earlier continuous-space baselines [2404.01752].

The principal limitations of Many-RRT* follow from its design. It requires generating and storing a large offline set \(M\) of sampled joint states and associated task poses, and its benefit depends on the quality and diversity of the sampled IK solutions [2603.04547]. Increasing the number of IK goals improves coverage of \(\mathcal{Q}_g\) but also increases memory use and the cost of cross-tree connection. This suggests a central trade-off of many-tree RRT* methods generally: robustness and globality improve when more roots are represented explicitly, but coordination overhead grows with the number of maintained trees.

A plausible synthesis is that Many-RRT* is best understood not as a single isolated planner but as a canonical design pattern for sampling-based planning under latent goal multiplicity. Whether the multiplicity comes from inverse kinematics, many destinations, many emergent replanning subtrees, or many agents, the core idea is the same: represent competing futures explicitly in the search structure, delay commitment, and let path cost and connectivity determine which branch should dominate [2603.04547][2106.03407][2205.14853].

Source: https://www.emergentmind.com/topics/many-rrt