Trajectory planning for high-degree-of-freedom manipulators in dynamic and partially predictable environments is often time-consuming and unsuitable for real-time robotics applications. To address this limitation, we propose a trajectory caching-based technique that accelerates the planning process by storing and reusing entire previously computed trajectories when similar motion queries are encountered. Unlike traditional approaches that rely on reusing individual states or initializing optimization-based planners with prior paths, our technique retrieves full feasible trajectories based on a simple yet effective geometric similarity metric applied to the start and goal configurations. The retrieved trajectories undergo an adaptation phase, including endpoint substitution and optional re-anchoring of the mobile base when required. To ensure robustness under stochastic execution conditions and environmental variability, all reused trajectories are subject to high-resolution tracing and collision checking before execution. This validation step guarantees safety in real-world deployments. The method is integrated with a fallback planner, enabling graceful degradation and completeness in cases where cached trajectories are not applicable. We evaluated our approach using a simulated mobile cleaning robot operating in public restrooms, where tasks such as opening stall doors, manipulating toilet seats, and spraying fluids require fast and repeated trajectory planning under varying environmental conditions. In addition to simulation, we validated the benefits of pre-training the trajectory cache under multiple environment configurations and tested the method on a real robot. Experimental results show that trajectory caching significantly reduces planning time - by more than a factor of four in some scenarios - without compromising safety or execution quality. These findings demonstrate that trajectory caching is a practical, efficient solution for repetitive service robotics tasks in partially structured and variable environments.
manipulators in dynamic and constrained environments remains a computationally expensive task, particularly when real-time performance is required. This problem becomes critical in service robotics scenarios, where delays in planning can directly affect the responsiveness and reliability of robotic behavior.
In this work, we consider a cleaning robot operating in public bathrooms, executing tasks such as opening stall doors, raising and lowering toilet seats, spraying chemicals and water, and vacuuming liquids. Some of these tasks require the robot's manipulator to find collision-free trajectories under the time constraints. In our experiments, we observed that trajectory planning may take several seconds in challenging environments, during which the robot becomes partially unresponsive. Reducing this delay is crucial for maintaining fluid task execution.
A technique for trajectory reuse through caching the entire trajectories is proposed. The key insight is that many planned trajectories exhibit structural similarity, especially when similar tasks are repeated in similar contexts. By caching previously computed trajectories and retrieving them based on proximity to the current request, we aim to reduce planning time without compromising safety.
This approach was implemented and evaluated in a simulated environment developed by Somatic Holdings Ltd., designed for benchmarking a bathroom-cleaning robot. Experiments show that our method reduces overall trajectory planning time by more than three times in repeated runs in simulation. Also using cache precalculating with simulation was tested on the real robot.
The contributions are as follows:
A cache-based trajectory reuse mechanism that supports online selection of previously successful plans was designed.
Was defined a proximity-based metric to evaluate trajectory relevance and describe an adaptation procedure to replace endpoints and, if necessary, re-anchor the base.
The method was validated in a realistic simulation and on a real robot and detailed experimental results were presented.
Shown the ability of using a cache that has been pre-trained in simulation to speed up path planning by a robot in real life.
A range of methods has been proposed to accelerate trajectory planning through the reuse of previously computed plans. These approaches can be categorized by the structure and complexity of their reuse mechanisms.
Early approaches in experience-based motion planning focused on storing large graphs to
accelerate future queries. One of the foundational methods is Probabilistic Roadmaps (PRMs),
which constructs a graph of collision-free configurations in the robot's state space for rapid path
finding [
Another group of methods aims to identify common motion patterns across tasks and store a set of
trajectory templates. In approaches like Experience-Based Planning with Sparse Roadmap Spanners
[
Machine Learning for Trajectory Selection. Recent work investigates the application of machine
learning to determine which past trajectories are relevant to new queries. Some approaches use
neural embeddings to predict the similarity between the current task and stored trajectories or
train classifiers to indicate reusability [
The concept of caching, storing data for fast access, also finds broad application in related domains.
For example, caching is used to optimize UAV trajectories for content delivery [
Inspired by this general idea, a recent approach known as RT-Cache [
Compared to the methods reviewed above, proposed approach intentionally focuses on a
lightweight mechanism: cache full trajectories and retrieve them using a simple geometric
proximity metric. While complex structures like experience graphs [
The proposed technique for path planning in variable environment centers on caching previously successful trajectories and reusing them when similar planning requests arise. Because the bathroom cleaning robot performs very similar tasks from day to day, but the trajectories performed are still not identical, using simple caching of entire trajectories with relatively small adjustments can be effective for this type of robot. This section describes the trajectory cache, the similarity metric used for retrieving candidates, and the adaptation and validation steps.
Trajectory cache structure: the cache is implemented as a collection of trajectories, each consisting of a sequence of key robot states (positions of the mobile base and joint angles of the manipulator). Between key points, the robot expected to move in a straight line in the robot's state space. For each new planning request, the cache is queried for existing trajectories whose start and goal states are similar to those of the current request.
Similarity metric: To identify relevant cached trajectories, we compute the following distances:
The base distance, denoted as dbase is calculated as the sum of the Euclidean distance between the mobile base positions ( p1 , p2) and the absolute angular difference (in radians) between their orientations (θ 1,θ2), as expressed in the following equation: (1) (2) dbase=‖p2− p1‖+|θ2−θ 1| where ‖⋅‖ represents the Euclidean norm;
The manipulator distance, denoted as darm is calculated as maximum joint angle difference between corresponding joints of the manipulator In radians) as expressed in following equation:
darm=max (|Ji2− J i1|) where Jik is an angle of rotation of i-th joint of a manipulator in k-th state.
The cached trajectory is slightly offset from the input initial and final states and during trajectory adaptation it received a collision.
The state of the environment has changed (for example, the angle of the adjacent doors has changed), so the trajectory that previously did not contain collisions now contains them.
Therefore, several different trajectories may be required to navigate between the same pairs of robot states. When multiple cached trajectories match the similarity metrics, they are sorted by the sum of the two distances. Up to three closest trajectories are selected.
Trajectory adaptation: each selected trajectory undergoes the following adaptation: A cached trajectory is considered relevant if both distances are below a fixed threshold (0.2 in our experiments).
There may be the following reasons why the cached trajectory failed the collision check: The initial and goal states are replaced with the current request’s start and goal states. If the base is fixed (non-moving) in the current request, all intermediate states in the trajectory are adjusted to match the base pose of the current request. Trajectory validation: to ensure safety, each adapted trajectory is traced with fine resolution:
Linear interpolation is performed with a step size of 0.04m (position), 0.04 radians (orientation), and 0.035 radians (joint angles).
Each interpolated state is checked for collisions.
Only collision-free trajectories are reused. Otherwise, a fallback planning procedure (in this
study the RRIS [
The experiments were conducted in a simulator developed by Somatic Holdings Ltd. that models a mobile cleaning robot operating in public bathroom environments. An image of the robot in the simulation can be seen in Figure 1.
The main parts of a robot are a movable base with three degrees of freedom and a 7-DOF
robotic arm UFACTORY xArm7 [
The robot is tasked with a variety of sub-tasks that require precise manipulation under spatial constraints. These tasks include:
Opening doors with handles.
Opening the stall doors.
Raising and lowering toilet seats.
Spraying chemicals.
Spraying water.
Drying the surfaces.
Vacuuming liquids.
Other routine cleaning actions.
Many of these sub-tasks require the planning of arm trajectories that avoid collisions with the environment, which includes doors, walls, stalls, and fixtures. Since some of the actions must be executed in a real time during plan execution, delays in planning can lead to visible pauses in the robot’s operation.
The simulation and a real life plan executing introduces variability in both the robot’s behavior and the environment state. This non-determinism originates from the stochastic physics engine and the inherently variable execution context. As a result, the robot may encounter slightly different configurations on each execution, even when following the same high-level plan.
The goal was to evaluate whether caching and reusing previously computed trajectories could reduce planning delays in such a dynamic setting. The robot’s control system was instrumented to measure the duration of all trajectory planning calls and logged whether the trajectory was retrieved from cache or planned from scratch.
In addition to the simulated cleaning environment, further evaluation using both simulation and a physical robot were conducted. To simulate environmental variability, multiple environment states were generated by changing the angles of stall doors between 0° and 90° in 10° increments. For each angle, the full cleaning plan was run in simulation and planning times were measured with and without caching.
Physical testing was also conducted, and four configurations were evaluated:
No caching (all paths planned online).
Caching enabled but initially empty (paths cached during execution).
Caching with pre-trained trajectories from simulation.
Second execution with accumulated real-robot cache.
Experiments in a simulation were conducted on a system with a 12th Gen Intel(R) Core(TM) i712700H, 32GB of RAM, and a GeForce RTX 3050 Mobile GPU. The exact parameters of the machine installed on the real robot cannot be disclosed due to a non-disclosure agreement, but in general the robot has a worse processor, but a better GPU. And because the trajectory planning was done on the CPU, the average runtime on the robot is slightly longer than in the simulation.
The caching system evaluated over multiple simulation runs of the same high-level plan. The baseline (without caching) involved 271 trajectory planning calls, totaling 18.319 seconds of planning time. In the first run with the caching mechanism, many trajectory requests had no cached equivalent, but some were still reused due to the fact that some trajectories planned within the same plan are close to each other. In the second run, the cache was more populated, resulting in significantly more reuse. The results of the caching system test in simulation can be seen in Table 1.
The results presented in Table 1 show a substantial reduction in planning time across repeated executions of similar plans. The second run in simulation demonstrates that over 93% of trajectory requests were fulfilled by the cache. This highlights the system's ability to exploit task repetition and structural similarities in the robot’s environment.
In the second test, collision safe trajectory planning with a caching system was tested on a real robot. Firstly a trajectory cache was precalculated in a simulation with different environmental states. Then precalculated cache usage compared to empty cache usage and to planning without a caching system. The results of the experiment can be seen in Table 2.
er of found and trajectories trajectories search validated planned by in cache es in trajectorie back-up after plan cache s in cache planner finished 0.751 14.031 4.202* 2.090* * the time of path planning and a cached trajectory search is a little higher on a real robot than in simulation, because the computer installed on a real robot has a little worse computational abilities as described in section 4. ** the speed-up factors for all simulation runs were calculated relative to the simulation run without caching (results presented in the first row of Table 1), and the speed-up factors for all real robot runs were calculated relative to the real robot run without caching (presented in the fourth row from the bottom of Table 2).
It is worth noting that even during the robot's first simulation run, without a pre-populated cache but with the caching mechanism enabled, the robot reused almost half (134 out of 271) of the trajectories that had to be planned (as can be seen in Table 1 and Table 2). This can be explained by the fact that some of the robot's movements are highly repetitive. Therefore, after the robot planned a trajectory for the first time while executing a task, it was able to reuse it on subsequent occasions, if the new configuration of the surrounding environment allowed it.
It was observed that as the cache filled up over simulation runs in different environments, the number of invocations of the backup planner progressively decreased, eventually reaching a low of two. Correspondingly, the total time for planning and cache lookups fell by a factor of approximately 4.2, from 14.872 seconds during the initial run to 3.542 seconds in the final run. When compared to the run without caching, the overall speed increased by a factor of 5.17. In contrast, the physical robot required the backup planner more frequently, even though its cache was pre-populated with all trajectories generated in the simulation. This discrepancy can be attributed to the simulation being a significantly more simplified and deterministic environment compared to the real world.
On the real robot, pre-training the cache cut planning time from ~27 seconds to ~7.7 seconds. On a second run, the system reused nearly all trajectories, reducing time to 6.3 seconds. These findings demonstrate that trajectory caching generalizes across environment configurations and can accelerate execution even on maps not previously visited by the physical robot.
Caching also contributed to the robot's responsiveness by minimizing pauses due to planning delays. Importantly, the system remained robust to variability in execution, as each reused trajectory was validated for safety before being accepted.
The results of the study support the practicality of caching entire trajectories for real-time robotic planning. The main advantage lies in the simplicity and speed of this approach, which makes it suitable for highly repetitive and partially structured tasks like restroom cleaning. In contrast, roadmap or ML-based reuse mechanisms introduce additional system complexity, memory usage, and require learning infrastructure.
We emphasize that this is not a criticism of such approaches, they may offer greater generalization in other settings. However, our hypothesis is that in high-dimensional state spaces with sparse plan reuse (e.g., 10-DOF robot in semi-structured map), the cost-benefit ratio may favor simpler caching schemes. This should be validated across domains.
Additionally, the impact of using cached trajectories on their overall quality warrants future evaluation. Since some planners optimize paths based on metrics such as clearance from the nearest obstacle, a reused trajectory may be of significantly lower quality than one specifically computed by the main planner. After all, a cached trajectory was likely generated for a different environmental state and may, therefore, not be optimal in the new configuration.
To build upon these findings and systematically investigate this trade-off, we have identified several key areas for future work. Among them are the following:
Adding environment-dependent indexing to the cache (e.g., door states, seat states). Combining caching with trajectory repair or smoothing algorithms.
Incorporating fallback planner failure cases into the reuse logic (e.g., recording failed plans). Comparing proposed method with roadmap-based methods on a prepared set of tests. Integrating machine learning methods to predict the relevance of cached trajectories depending on the current environment state (e.g., map configuration, obstacle layout). Using machine learning to better match cached trajectories even when start and goal configurations are farther from those of the stored ones, potentially expanding the reuse range of the cache.
This work presents an effective trajectory caching strategy for robotic manipulators operating in variable but structured environments. By reusing entire trajectories and adapting them to new requests, planning delays were significantly reduced while maintaining safety. Experiments in simulation and on a real robot confirm that pre-training the cache enables the robot to execute plans with minimal latency. Already on the first run of the plan on real robot, the use of caching allowed to reduce the execution time by 3.5 times, and on the second run, the planning time was further reduced, reaching a total acceleration of 4.3 times. Such performance gains are particularly valuable in applications where minimizing setup time and maximizing operational throughput are critical. It is hypothesized that, compared to roadmap-based methods, the proposed technique is more lightweight and better suited for tightly scoped but high-dimensional robotic tasks. This hypothesis requires experimental validation.
Beyond the specific cleaning scenario, the proposed trajectory caching approach may also be applicable to other domains involving repetitive motion planning, such as warehouse logistics, industrial manipulation, or assistive service robotics. These areas share similar challenges of frequent re-planning under partially predictable conditions, where caching entire trajectories could provide comparable benefits in speed and reliability.
This research did not receive any specific grant from funding agencies in the public, commercial, or not-for-profit sectors.
The authors would like to express their deep gratitude to Somatic Holdings LTD, whose codebase, the simulation environment and the infrastructure greatly facilitated the development of the mechanism presented in this paper.
During the preparation of this work generative AI tools (Gemini 2.5 Pro, ChatGPT 5) have been used for grammar checks, text polishing. After using these tools, the authors reviewed and edited the content as needed and take full responsibility for the publication’s content.