WorksComputer Science
Plan your Self-Adaptation! Ontology-Mediated Task and Architecture Co-adaptation Planning for Robots
Abstract
Autonomous robots may need to adapt both their task plans and architectural configurations as operating conditions change. These decisions are interdependent: architectural configurations determine which actions a robot can perform, while task plans determine which capabilities are required. This paper presents PLANTA, an ontology-mediated approach to task and architecture co-adaptation that considers these dependencies during mission planning. PLANTA uses an ontology expressed in the Web Ontology Language to represent architectural alternatives and their associated functional and quality requirements, while the Planning Domain Definition Language defines task actions and mission goals. By automatically translating and integrating these models, PLANTA enables joint planning of task and reconfiguration actions. The approach uses satisficing planning and replans when changes during execution invalidate the current plan. PLANTA is evaluated in two robotic scenarios involving underwater inspection and ground navigation. The results support the feasibility of runtime co-adaptation and show lower planning time and memory consumption compared with optimal-policy generation in the evaluated navigation scenario, while producing plans of similar quality.
Introduction
Autonomous robots are required to operate reliably in increasingly complex environments and to perform a larger number of tasks with distinct functional and quality requirements, potentially requiring different architectural configurations to satisfy them. A key challenge in designing such systems is ensuring that the robot continues to meet its requirements throughout mission execution, particularly under uncertainty, such as sensor failures or environmental disturbances [15, 28]. For example, an underwater robot might require different sensor configurations depending on the water visibility, or it might need to navigate through different paths depending on water currents. Addressing these challenges requires coordinating task execution and architectural adaptation while accounting for their interdependencies.
Task and architecture co-adaptation (TACA) [13] addresses the interdependencies between task execution and architectural adaptation. Reactive TACA approaches such as ROSA [40] select a configuration for each action only when that action begins executing, without accounting for how the choice constrains the rest of the mission. However, selecting a suitable configuration for the current action alone does not establish whether subsequent actions can be performed under the conditions anticipated along the mission. Considering these dependencies during mission planning allows configuration requirements to influence the task plan before execution begins, so that each
Authors’ addresses: Gustavo Rezende Silva, [email protected], Cognitive Robotics, Delft University of Technology, Delft, The Netherlands; Tobias John, [email protected], Robotron Datenbank Software GmbH, Dresden, Germany; Francisco Martín, [email protected], Intelligent Robotics Lab, Universidad Rey Juan Carlos, Fuenlabrada, Madrid, Spain; Einar Broch Johnsen, [email protected], Department of Informatics, University of Oslo, Oslo, Norway; Carlos Hernandez Corbato, [email protected], Cognitive Robotics, Delft University of Technology, Delft, The Netherlands. configuration choice is made with its downstream task consequences in view. To the best of our knowledge, the approach by Cámara et al. [13] is the only approach that jointly plans task actions and reconfiguration actions and produces a complete plan ahead of execution. Their approach, however, requires substantial planning time and memory and relies on domain models expressed across multiple specification languages with manually developed integration code, increasing modeling effort and the potential for errors. Furthermore, their approach requires modeling probabilities to enable optimal planning, although these probabilities can be difficult to estimate accurately.
To address these limitations, this paper proposes PLANTA, an ontology-mediated approach that formulates task and architecture co-adaptation as a single planning problem by automatically integrating task and architectural knowledge. PLANTA uses a Web Ontology Language (OWL) ontology [1] to represent the functional requirements of robot actions, the architectural alternatives that realize those requirements, and the quality attributes and requirements used to assess the applicability and utility of each alternative. The Planning Domain Definition Language (PDDL) [27] describes task actions, the current system state, and mission goals. Architectural knowledge is automatically translated into PDDL and integrated with the task model, allowing task actions and architectural reconfiguration actions to be considered within the same search space. This integration preserves a separation between task modeling and architectural knowledge modeling. The resulting problem can be solved by standard PDDL planners. To support timely runtime adaptation, PLANTA favors satisficing planning over guaranteed mission-level optimality. Rather than explicitly modeling uncertainty and its probabilities, it plans from the currently observed state and handles changes during execution through replanning when monitored conditions invalidate the current plan. By relying on two established modeling languages and automating their integration, PLANTA aims to reduce modeling effort.
Figure 1 depicts the PLANTA framework across design time, deployment time, and runtime. At design time, the system architecture is modeled using the PDDL-TOMASys ontology, and the task problem is modeled in PDDL. At deployment time, Owl2PDDL translates the ontology into PDDL, combines it with the planning problem, and incorporates their mutual dependencies, i.e., TACA concerns. At runtime, the planning system, based on PlanSys2, jointly plans and executes task and reconfiguration actions. PDDL-TOMASys builds upon the Teleological and Ontological Metamodel for Autonomous Systems (TOMASys) [2, 14] and draws inspiration from the ROSA model [40].

Figure 1. PLANTA framework, organized into design time, deployment time, and runtime, separated by dashed vertical lines. Some PlanSys2 nodes are omitted for clarity, and the Planner and Plan Execution components shown were extended as part of this work.
PLANTA is evaluated with respect to feasibility, performance efficiency, and scalability on two use cases: an autonomous underwater vehicle (AUV) scenario from the SUAVE exemplar [39], and an autonomous ground vehicle (AGV) scenario adapted from [13]. These dimensions are formulated as research questions RQ1–RQ3 in § 8. Feasibility (RQ1) is addressed by implementing PLANTA and integrating it with PlanSys2, an existing planning system for robotics. This required extending PlanSys2 with derived predicates and existential preconditions [16], PDDL constructs that the models generated by Owl2PDDL rely on. The results of running PLANTA on the ROS 2-based SUAVE exemplar support the feasibility of applying it to robotic systems. Performance efficiency (RQ2) is assessed on the AGV use case, where PLANTA is, at the median, 3.00 times faster than the approach by Cámara et al. [13] and its peak memory usage is 6.84 times smaller, while both approaches produce plans with near-identical path length and estimated remaining battery at the end of the mission. In the AGV use case, scalability (RQ3) is assessed by varying the map size, the number of architectural configurations, the number of quality requirements, and the number of mission-level PDDL action schemas, independently and in combination. The results show that satisficing planning remains tractable in scenarios where optimal planning becomes impractical, supporting the use of PLANTA in robotic applications that require online task-level replanning.
The main contributions of this paper are:
an ontology-mediated planning approach for mission-wide task and architecture co-adaptation that combines task and reconfiguration actions in a single PDDL formulation and supports satisficing planning with runtime replanning.
an open-source implementation of the proposed approach, designed for integration with ROS 2-based robotic systems, including an extension of the PlanSys2 framework to support derived predicates and existential preconditions in PDDL.
a systematic evaluation of the proposed approach, including a comparison with the state-of-the-art approach by Cámara et al. [13] and a scalability analysis that demonstrates the feasibility of satisficing planning in regimes where optimal planning becomes impractical.
Running Example
Throughout this paper, the SUAVE exemplar [39] is used as a running example to illustrate the concepts introduced by PLANTA. In SUAVE, an Autonomous Underwater Vehicle (AUV) carries out an underwater pipeline inspection mission. The mission is structured as a sequence of task actions: search for the pipeline, and follow and inspect the pipeline. The SUAVE scenario is extended in ROSA [40] with a third action, recharge battery, so that the scenario requires task and architecture co-adaptation.
During mission execution, the AUV is subject to three sources of uncertainty. corresponds to thruster failures: if a thruster fails during or , the system requires reconfiguring the architecture to recover the affected thruster. corresponds to the variation in water visibility: reduced visibility during causes the system to select a lower-altitude search configuration. Both and require architecture-level adaptation only, leaving the task plan unchanged. corresponds to a critical drop in battery level: if battery level reaches a critical threshold during or , the system must interrupt the current action and execute , which requires a dedicated architectural configuration. Hereafter, the scenario with and is called the original use case, and the scenario with all three uncertainties the extended use case.
In this work, each task action in the mission is encoded as a PDDL action in the planning domain. For example, the search_pipeline action (Listing 3) encodes . Throughout the paper, this action is used to illustrate how PLANTA transforms a regular action into a managed action that integrates functional and quality requirements derived from the PDDL-TOMASys ontology (Listing 4), as described in § 6.2.
Related Works
Self-Adaptive Robotic Systems
The mapping study on “robotics software architecture-based self-adaptive systems” (RSASSs) by Alberts et al. [3] identified 37 primary studies published since 2011. Among these, only four works [13, 18, 29, 36] explicitly address, to varying extents, the dependencies between task execution and architectural adaptation. Additionally, the two studies [11, 44] also explore this relationship, and the ROSA framework proposes a systematic solution to TACA [40]. However, only the approaches [11, 13, 40] fully address TACA. With respect to knowledge-based methods, Alberts et al. identified six works [10, 23, 33, 34, 36, 39] that utilize knowledge representation techniques to encode the information required for adaptation. From these, the works [10, 39] focus on demonstrating the use of Metacontrol [9, 22] in specific robotic applications rather than proposing complete solutions for RSASSs. Concerning planning, using PDDL-based planners for RSASSs is still mostly unexplored. Alberts et al. identified only the approach “Model Based Diagnosis (MBD)” [45, 46], which employs PDDL-based planning to generate architectural adaptation plans, without explicitly targeting TACA.
Cámara et al. [13] proposed a solution to TACA that generates an optimal policy for task execution and architectural configuration. Their method is decomposed into four steps: (i) generate all legal architectural configurations based on the robot’s architecture model, (ii) generate all possible reconfiguration plans between configurations, (iii) generate the best task plans to accomplish the robot’s mission goal, (iv) compute an optimal policy for task execution and configuration, given the reconfiguration and task plans. Their experiments show that the generation time is impractical: Generating an optimal task and configuration policy for an AGV operating in a graph-like environment with 58 nodes and with six architectural configurations available takes, on average, 15.1 seconds.
Silva et al. [40] proposed ROSA as a solution to TACA, focusing on providing a reference framework for robot self-adaptation that promotes reusability, composability, and extensibility. A limitation of ROSA is that it only supports reactive adaptation of the robot’s configuration. ROSA determines the robot’s configuration for each action only when it starts executing, and it does not produce a complete configuration plan ahead of time.
To address the limitations of these approaches, this work proposes an ontology-mediated planning approach that enables the timely computation of a satisfying task and configuration plan without relying on probabilistic models of real-world uncertainties.
Combining Ontologies and Planning
Knowledge and Action Bases. Several works have explored combining ontologies with planning problems. The approach proposed in this work is most closely related to the work on Knowledge and Action Bases (KABs) [20], where an ontology is used to provide additional insights about a planning state by using queries to the ontology in the planning domain. The actions in the planning domain describe changes to the ontology over time.
There are different approaches to generate a plan for KABs, namely (i) rewriting ontology queries to complex preconditions [12], (ii) rewriting ontology axioms to derived predicates [7], and (iii) enriching the planning domain with grounded answers to the ontology queries [26]. All the approaches have in common that they perform planning as a two-step process: First, the ontology is analyzed and a new planning domain is created that encodes the axioms from the ontology. Secondly, an off-the-shelf planner is used to find a plan using the new domain and the original problem. The first approach only works for axioms in DL-Lite [12] and leads to rather long planning times [7], despite optimizations in the expansion algorithm [8]. The second approach requires a Horn-Logic fragment of the ontology axioms, but it is, in general, the fastest among the three [7, 26]. The third approach supports all kinds of axioms, but it is slower than the second approach, especially in instances where finding a plan is relatively simple [26].
The approach presented in this work is most similar to the second approach, where ontology axioms are encoded as derived predicates in the planning formulation. However, due to the special requirements of TACA, a custom translation from axioms to derived predicates is used.
Ontologies as Modeling Languages. Some studies have explored the use of ontologies as a modeling language for planning problems in the robotics domain [5, 6]. These efforts try to make modeling of complex domains easier by providing frameworks for complex classes and their relations. It is a known limitation of PDDL that modeling domains with complex types directly in PDDL is not well supported [19]. This work adopts a related approach by encoding PDDL type information within the ontology to support semantically rich planning representations.
Background
PDDL Planning
This work adopts a standard definition of planning problems based on a first-order (lifted) planning formalism, as defined in PDDL [17].
A planning task is defined as a tuple , where denotes the planning domain and the problem instance. The domain and the problem instance must be defined over the same finite set of predicate symbols .
A planning problem instance is defined as a tuple , where is a finite set of objects, is the initial state represented as a set of ground atoms, and is the goal condition, i.e., a set of ground atoms that must be satisfied in the final state. Ground atoms are constructed using predicate symbols from and constants/objects from .
A planning domain is defined as a tuple where is a set of actions and is a set of derivation rules. An action is a tuple , where name is the action name, are the action parameters, pre is a first-order formula describing the precondition that needs to be satisfied before the action, add and del represent, respectively, the set of atoms that are added and deleted from the current state when the action is performed. A grounded action is an action in which the variables in are substituted by objects from . A derivation rule is of the form where is a vector of variables, and is a first-order formula with free variables describing the condition when should hold. All predicates that occur in such a rule are called derived predicates.
Planning is the search for a plan , i.e., a finite list of grounded actions, where the ordered application of the grounded actions produces a state that contains the goal atoms, i.e. .
PlanSys2
This work uses PlanSys2 for automated planning with off-the-shelf planners, for runtime plan execution, and for managing the PDDL knowledge base, which is updated at runtime with information from the robot’s perception system. PlanSys2 transforms task plans into plan graphs that capture dependencies between actions and allow non-interfering actions to execute in parallel. These graphs are then converted into behavior trees (BTs) [31] for runtime execution.
During execution, the BT continuously checks the action preconditions specified in the PDDL formulation and triggers replanning when a precondition is violated. Consequently, the PDDL constructs used in a planning task must be supported by both the selected planner and PlanSys2’s mechanisms. PlanSys2 partially supports PDDL 2.1 up to level 3 [17] and lacks several PDDL features that this work requires. Section 7.2 lists them and details the extensions to PlanSys2 that add this support.
Description Logic Ontologies
This work uses description logic ontologies [4]. In this setting, an ontology is a set of axioms defined over a common vocabulary . The vocabulary is partitioned as , where , , and denote the sets of concept (class) names, role (property) names, and individual names, respectively.
There are two types of axioms that form an ontology: (i) terminological box (TBox) axioms, which describe relations between concepts and (ii) assertional box (ABox) axioms that describe assertions. TBox axioms are of the form where are concepts. Such axioms describe a sub-concept relationship, i.e., that all elements in are also elements in . ABox axioms are of the form and , where is a concept, and are individual names and is a role name.
Concepts are complex expressions built from the vocabulary . Depending on the logical fragment used, the concepts allowed vary. In this work, the fragment (Attributive Language with Complement and Inverse roles) is sufficient. It builds concepts from concept names using negation, conjunction, disjunction, and existential and universal restrictions over roles and their inverses.
Additionally, an ontology can be extended with rules defined with the semantic web rule language (SWRL) [24], which are an additional way to infer facts by providing a consequent that is inferred when the antecedent holds. A rule (antecedent, consequent) is a pair of sets of atoms. Atoms are either of the form or , where is a concept name, is a role name or a (numeric) comparison operator, and and are either variables, individual names or data values.
TOMASys Ontology
The Teleological and Ontological Metamodel for Autonomous Systems (TOMASys) [2, 14] is an ontology designed to capture the knowledge necessary for enabling architectural adaptation in robotic systems. It models the system’s functionalities, the architectural alternatives that realize each functionality, the runtime quality requirements associated with these functionalities, and the expected quality output for each architectural variant.
Classes. TOMASys’ class names are defined as follows:
An individual of the Function class represents a system functionality. A FunctionDesign individual represents an architectural variant that realizes a particular function, and a single functionality could have several designs that differ in the quality they provide. A Component individual represents a hardware or software element that a FunctionDesign requires. In SUAVE, there is a generate search path functionality that is realized by three function designs that perform spiral search at different altitudes. The six AUV thrusters are represented as Component individuals, which are required by the function designs of the maintain motion functionality.
A QAtype individual represents a type of quality attribute (QA) [41], and a QAvalue individual represents a specific value of a QAtype, which can be used to express quality requirements, the estimated quality output of function designs, and runtime measurements. In SUAVE, water visibility and search performance are QAtypes. Each generate search path function design has a minimum required water visibility value and an estimated search performance. At runtime, the perception system reports the measured water visibility as a QAvalue individual. In SUAVE extended, battery level is a QAtype used to express the requirement that the measured battery level shall not go lower than 25%. TOMASys also defines runtime elements. An Objective individual represents a runtime goal to have a Function realized, and a FunctionGrounding individual records which FunctionDesign currently meets that Objective. Further relations link them to the measured QA values.
Relations. In TOMASys, solvesF represents which FunctionDesign solves which Function, requiredBy represents that a Component is required by a FunctionDesign, isQAtype represents that a QAvalue is of a given QAtype, and hasQAestimation represents the expected QAvalue of selecting a FunctionDesign. In SUAVE, isQAtype relates a value such as low to the water visibility QAtype, and hasQAestimation gives each spiral design its required water visibility QAvalue, e.g., low for the lowest-altitude design. In addition to TBox and ABox axioms, TOMASys contains SWRL rules that infer the system status at runtime, e.g., whether a function design is realizable given the status of its required components.
PDDL-TOMASys
This work proposes the PDDL-TOMASys ontology to enable TACA solely through ontology-mediated planning. PDDL-TOMASys builds upon the TOMASys ontology [2, 14], but TOMASys cannot be reused for this purpose without modification. It offers no representation of robot actions, and no representation of the relation between an action and the functionalities it requires, i.e., the action’s functional requirements. It was also designed under assumptions about the organization of planning and reasoning that do not hold for PLANTA.
The first limitation is that TOMASys gives the planner no way to determine which configuration must be active for a given action to be executable. In SUAVE, for example, the search_pipeline action requires the generate search path and maintain motion functionalities. A suitable FunctionDesign must therefore remain grounded for each functionality throughout the action’s execution. To address this limitation, PDDL-TOMASys introduces an explicit representation of action functional requirements, defined below. PLANTA combines these explicitly modeled functional requirements with PLANTA’s runtime precondition monitoring (see § 4.2). If a constraint violation renders a grounded FunctionDesign unrealizable, the resulting execution failure prompts the PLANTA controller to request replanning.
The second limitation concerns two assumptions under which TOMASys and the Metacontrol managing system were designed. First, it assumes a separation of responsibilities between task and configuration planning: an external component, without direct access to the knowledge base, is responsible for selecting the robot’s actions (task planning), while an internal component within the managing subsystem, with direct access to the knowledge base, handles the architectural configuration (configuration planning). The second assumption is that a monotonic reasoner, driven by an additional procedural component, writes all inferred facts permanently into the knowledge base. In contrast, PLANTA tightly integrates task and configuration planning within a single component that has direct access to the knowledge base, and it applies virtualized monotonic reasoning, in which inferred facts exist only transiently during the reasoning cycle and are not written into the knowledge base.
These differences call for a modeling strategy that diverges from TOMASys in three respects: (i) modeling which functionalities of the system must be managed at runtime, (ii) modeling the runtime state of the system, and (iii) defining the inference rules accordingly. Concretely, PDDL-TOMASys removes the Objective and FunctionGrounding classes together with their runtime relations, redefines functionGrounding as an object property, and introduces the Action class and the requiresF relation to connect actions to the functionalities they need. The remainder of this section formalizes PDDL-TOMASys using description logic.
Classes and relations. PDDL-TOMASys’s classes and relations are defined as follows:
To represent the functional requirements of actions and support TACA, this work introduces the class Action and the object property requiresF into the ontology. The requiresF relation specifies the Functions necessary to perform each action, thereby informing the planner which functionalities must be managed and activated to enable the execution of a given action, e.g., requiresF(a_search_pipeline, f_generate_search_path).
To capture which configuration (i.e., FunctionDesign) solves a Function at runtime and whether it is active, the ontology includes the functionGrounding relationship1 that relates a Function to the FunctionDesign that solves it, e.g., functionGrounding(f_generate_search_path, fd_spiral_high). Additionally, this work introduces a data property f_active to indicate whether a Function is currently activated, i.e., whether a functionGrounding exists between it and a FunctionDesign other than fd_unground.
To support the inference of the most suitable FunctionDesign based on utility, this work introduces the fdBetterUtility relation, which relates a higher-utility FunctionDesign to one with lower utility, e.g., fdBetterUtility(fd_spiral_high, fd_spiral_medium). This relationship is inferred at runtime by the planner, enabling PLANTA to reason about TACA solely through ontology-mediated planning.
To represent that a Function should be deactivated, the base ABox includes one additional individual, fd_unground, asserted to be a FunctionDesign through FunctionDesign(fd_unground). Grounding a Function with fd_unground denotes that no configuration is currently active for it. The relations solvesF(fd_unground, ?f) that let fd_unground ground any Function ?f are inferred by the SWRL rule
rather than asserted in the ABox. To deactivate a Function ?f, PLANTA asserts functionGrounding(?f, fd_unground), e.g., functionGrounding(f_generate_search_path, fd_unground).
SWRL rules. To infer the system status, the following SWRL rules are added to the ontology.2 They infer, in order, that a FunctionDesign ?fd is not realizable when a required component fails, that a Function ?f is active when it is grounded with a FunctionDesign other than fd_unground, which of two FunctionDesigns solving the same Function has the better utility, and the utility of a FunctionDesign from its performance QA estimation. The last rule is generic and can be replaced by application-specific rules.
(realizability)
(activation)
(better utility)
(utility)
Planning Method
To enable ontology-mediated planning with PDDL-TOMASys for solving TACA, this work introduces PLANTA (see Figure 1). In PLANTA, the task planning problem is specified in PDDL, while the adaptation logic is modeled in an OWL ontology conforming to PDDL-TOMASys. These two models are automatically combined into a single PDDL model, as described in § 6.1. The resulting PDDL model is transformed once again to include TACA concerns by converting the task actions into managed actions. In the running example, search_pipeline (A1) becomes a managed action. At runtime, a planning system uses this final PDDL model for task and configuration planning, as well as for managing plan execution. § 6.1 explains the OWL to PDDL transformation, and § 6.2 details the final transformation that incorporates all TACA-related concerns.
OWL to PDDL translation
The translation algorithm used in this work for encoding the axioms of the OWL ontology into the PDDL formulation follows the approach proposed by Borgwardt et al. [7], where the OWL axioms of the ontology are rewritten into derived predicates in PDDL (see also § 3.2).
To add the OWL axioms to the PDDL domain, one has to translate and incorporate an ontology , with class names , relation names , and individual names , into an existing planning formulation of the form , with and over the set of predicates . As summarized in Table 1, the translation extends the predicates to , the objects to , and the initial state to , where contains the grounded atoms obtained from the class and relation assertions in the ABox.
| Concept OWL Ontology | Concept PDDL | Example OWL Ontology | Example PDDL |
| Individual | Object | f1 | (f1 - object) |
| Class | Unary predicate | Function | (Function ?f) |
| Class Assertion | Grounded unary predicate | Function(f1) | (Function f1) |
| Relation | Binary predicate | functionGrounding | (functionGrounding ?f ?fd) |
| Relation Assertion | Grounded binary predicate | functionGrounding(f1, fd1) | (functionGrounding f1 fd1) |
Table 1. Mapping between OWL ontology and PDDL concepts following the approach of [7].
Schema information encoded in the TBox and in SWRL-rules is translated into derivation rules. Sub-concept relations in the ontology are translated to derivation rules of the form . SWRL-rules (antecedent, consequent) are translated to derivation rules
where contains variables occurring in the consequent and contains variables occurring only in antecedent, see Figure 2 for an example. The new set of derivation rules is where are the derivation rules generated from sub-class axioms and SWRL rules. The new planning task is then defined as over the set of predicates , with and .

Figure 2. Transformation of a SWRL rule into its equivalent PDDL derived predicate.
Planning task transformation for co-adaptation
Finally, to support task and configuration planning, this work proposes transforming the planning task , which was produced by the OWL to PDDL translation, into a new planning task that incorporates adaptation concerns. This includes the addition of reconfiguration actions and the modification of action preconditions to account for functional and quality requirements. Specifically, each action , where is the set of actions subject to adaptation, is replaced with a managed action , the original action is removed from , and a single pair of reconfiguration actions is added to the domain.
The effect of this transformation is illustrated using the search_pipeline action from the running example (Section 2), which encodes A1 and requires the generate search path and maintain motion functionalities. Listing 3 shows its original form, in which the only precondition is that the robot has started and the sole effect is that the pipeline has been found. Listing 4 shows the managed version, in which the preconditions are extended with functional and quality requirements for both functionalities, ensuring that each is grounded to an active, non-failed FunctionDesign with the highest available utility. For example, while water visibility is high the highest-utility function design for generate search path is the high-altitude spiral design (fd_spiral_high). When visibility drops during A1 (uncertainty U2), that design is no longer valid, so the managed precondition no longer holds and replanning inserts a reconfiguration action in the plan that re-grounds generate search path to the medium-altitude spiral design (fd_spiral_medium), which then satisfies the bestFD requirement.
Additionally, the managed precondition requires that all functions not required by the action are inactive, preventing conflicts between components that serve different task actions. For example, the function used to follow the pipeline in A2, f_follow_pipeline, must be inactive while search_pipeline executes, as enforced by the trailing (not (F_active f_follow_pipeline . . . )) condition in Listing 4. This constraint ensures that only the architectural configuration appropriate for the current task action is active at any time.
(:action search_pipeline
:parameters (?p − pipeline ?r − robot)
:precondition (and (robot_started ?r))
:effect (and (pipeline_found ?p)))
Listing 3. Original search_pipeline action
(:action search_pipeline
:parameters (?p − pipeline ?r − robot)
:precondition (and
(robot_started ?r)
;; ?a = a_search_pipeline; ?f1 = f_generate_search_path, ?f2 = f_maintain_motion
(exists (?a ?f1 ?f2 ?fd1 ?fd2)
(and
(Action ?a)
(= ?a a_search_pipeline)
(not (= ?f1 ?f2))
(requiresF ?a ?f1)
(F_active ?f1 true_boolean)
(FunctionGrounding ?f1 ?fd1)
(not (Fd_realisability ?fd1 false_boolean))
(not
(exists (?fd1_b)
(and
(not (= ?fd1 ?fd1_b))
(SolvesF ?fd1_b ?f1)
(not (Fd_realisability ?fd1_b false_boolean))
(FdBetterUtility ?fd1_b ?fd1))))
;; same conditions for ?f2 (f_maintain_motion)
;; every functionality not required by A1 must be inactive. Here, f_follow_pipeline required by A2
(not (F_active f_follow_pipeline true_boolean))))
:effect (and (pipeline_found ?p)))
Listing 4. Managed search_pipeline action
Formally, the transformation of an action into a managed action is defined as follows. Let denote the action name, the parameters of action , its preconditions, and and the sets of atoms added to and removed from the state, respectively, when is executed. The managed action is a tuple
with
Where the action’s requirements are expressed in terms of functional and quality requirements:
The final condition requires the functions to be pairwise distinct, so that a single function cannot satisfy several functional requirements. For search_pipeline, , and and are the generate search path and maintain motion functions in Listing 4.
A functional requirement is defined with the functionalReq(, , ) predicate, which holds when a Function required by an Action has a grounded FunctionDesign solving it:
Quality requirements can be defined with the predicate bestFD(, ), which holds if there does not exist another realizable FunctionDesign that solves function with better utility than . When specified as a quality requirement, the bestFD predicate constrains the planner to select a FunctionDesign with the highest utility among realizable alternatives for the corresponding function. This local requirement does not imply mission-level optimality, as PLANTA computes a satisficing task and reconfiguration plan without optimizing overall mission utility. Different expressions can be used to define other types of quality requirements.
The two additional reconfiguration actions, and , are responsible for selecting architectural configurations by grounding FunctionDesigns to their corresponding Functions. This is achieved by inserting predicates of the form into the state. Specifically, is applied when a already exists for function , whereas is applied when the function is not grounded.
Both reconfiguration actions have similar parameters: a target Function, a new FunctionDesign to be selected, and, in the case of only, the currently active FunctionDesign. In both actions, the preconditions ensure that the new FunctionDesign is valid. The only difference between them is whether an existing FunctionDesign must be deactivated before activating a new one. Formally, the two reconfiguration actions are defined as and , with:
In the running example, the visibility drop described above is handled by reconfigure1 with the generate search path function, , and . The resulting planning task is defined as over the set of predicates , where , and with . That is, only the set of actions is modified.
An off-the-shelf PDDL planner solves directly and returns a combined task and configuration plan that interleaves reconfiguration and managed actions, for example . PLANTA executes this plan with PlanSys2, which re-evaluates action preconditions as runtime information such as measured QAValue individuals updates the state, and replans when a precondition no longer holds (§ 4.2 and § 7.2).
Implementation
PLANTA is implemented as a ROS 2-based system to facilitate its use in robotic applications. It integrates PlanSys2 [30] for planning and plan execution, System Modes [35] for managing system reconfiguration, and a custom ROS 2 package that implements the OWL to PDDL translation.
Owl2PDDL tool
To apply the OWL to PDDL translation, this work provides a standalone Kotlin-based executable that performs the translation independently of ROS 2. Additionally, a ROS 2 package is provided to integrate the tool with the ROS 2 ecosystem. While the transformation approach builds on prior work that translates OWL axioms into PDDL rules [7], existing tools are not well-suited for robotic self-adaptation. In particular, the PDDL-TOMASys ontology includes numerical values that require translation, a feature unsupported by current tools. Additionally, developing a new tool allowed for optimizations, such as specifying the PDDL types of ontology instances. These types are exported to the PDDL domain model to help reduce planning time. Both the OWL to PDDL tool and the associated ROS 2 package are publicly available.3
Planning and plan execution
For planning and plan execution, this work leverages PlanSys2. However, since PlanSys2 does not support all PDDL requirements imposed by the OWL to PDDL transformation step, this work extends PlanSys2 to support existential preconditions (PDDL 1.1), derived predicates (PDDL 2.2), equality between non-numeric objects (e.g., ), negation of composite expressions (e.g., ), and the execution of non-durative actions.
This work uses the Fast Downward [21] planner for automated planning since it supports derived predicates and existential preconditions. To use Fast Downward with PlanSys2, this work implements a PlanSys2 plugin for the Fast Downward planner, which is publicly available online.4
Adding support for derived predicates and existential preconditions in PlanSys2 resulted in conceptual changes to the preconditions evaluation and apply action effects algorithms that are used in the plan execution process. Furthermore, it required the addition of a mechanism that is able to evaluate derived predicates at runtime to infer new predicates in a reasonable amount of time. The other extensions to PlanSys2 aforementioned required only additional implementation. The synthetic domain in Figure 3 is used throughout this section to keep the examples compact. The derived predicates that Owl2PDDL generates from the PDDL-TOMASys ontology (§ 6.1) share its structure: they are defined over other derived predicates and use existential quantification and negation. Predicates such as f_active and fd_realisability are re-derived from base facts such as functionGrounding that the reconfiguration actions modify (§ 6.2).
Figure 3. PDDL example with derived predicates and existential preconditions.
Preconditions evaluation algorithm. In PlanSys2, the preconditions evaluation algorithm Evaluate(, ) determines whether the preconditions of action are satisfied in a given state . This algorithm is used both during plan graph construction [31] to build a behavior tree for plan execution, and at runtime by the resulting plan graph BT to continuously verify the feasibility of executing actions. The current evaluation algorithm assumes that there are no free variables in the preconditions, i.e., all parameters are grounded with objects during the planning process. This assumption no longer holds when existential preconditions are introduced. For example, consider the plan as a valid solution to a problem instance of the planning domain shown in Figure 3, where and . In this case, the existential precondition introduces a free variable that remains ungrounded at planning time.
Evaluating such preconditions requires checking whether there exists an object such that the variable can be unified with , and the resulting grounded formula satisfies the logical condition defined in the precondition body. In the example, this corresponds to verifying whether there exists an object such that the atom is contained in the current state , e.g., .
With the addition of derived predicates, the evaluation algorithm is no longer limited to checking action preconditions, it must also evaluate the conditions of derived predicates, i.e., Evaluate(, ), where . In this setting, the evaluation of a precondition cannot be performed by simply verifying whether it is satisfied in the current state . Instead, the relevant derivation rules must be applied to the current state to determine whether the predicates can be derived. For example, in the planning domain shown in Figure 3, given a state , the precondition of action1 is satisfied only if the derived predicate (lines 1–2) is successfully inferred. To support the evaluation of existential preconditions and derived predicates in PlanSys2, this work proposes the evaluation algorithm described in Algorithm 1.
Derived predicates resolution. The derived predicate resolution implemented in this work adheres to the definition of derived predicates introduced by Thiébaux et al. [43], which extends the original PDDL 2.2 [16] specification. This definition allows derived predicates to depend on other derived predicates, including recursive self-dependencies, and allows negated derived predicates in their preconditions, provided that such negation does not occur within a recursive cycle.
To address this problem, this work proposes representing the derived predicates from a PDDL formulation as a directed graph. For example, the PDDL formulation described in Figure 3 can be represented as the graph depicted in Figure 4a.
Figure 4. Derived predicates resolution graphs for the PDDL formulation in Figure 3: (a) the full dependency graph and (b) the pruned graph for the plan . The predicates predicateAA and predicateC are omitted to simplify the visualization, as they are not relevant to the graph structure due to having no child predicates.
In this graph, nodes in the upper layer (depth 0) represent predicates, functions, or instances, while nodes in the lower layers (depth one or more) represent derived predicates. The edges indicate dependencies between the nodes, with arrows pointing from parent to child nodes. For example, the edge from predicateA to inferredA indicates that the latter depends on the former.
To solve derived predicates, this work introduces Algorithm 2. It partitions the resolution graph into strongly connected components (SCCs) using Tarjan’s algorithm [42], which separates acyclic from cyclic components. The acyclic components are resolved in topological order, while the cyclic components are resolved using a fixed-point iteration. Root nodes are considered solved by definition, as they correspond to non-derived predicates. For instance, in the graph shown in Figure 4a, the derived predicates inferredB and inferredAB form a cycle, whereas the other derived predicates are acyclic.
Apply action effects algorithm. With the addition of derived predicates, applying an action’s effects can invalidate previously derived predicates and make new ones derivable. Instead of recomputing all derived predicates, this work exploits the structure of the derived predicates graph to re-evaluate only the derived predicates that depend on the predicates modified by the effects (Algorithm 3). For example, in the PDDL domain described in Figure 3, applying the action (action1 instance1) adds (predicateB instance1) to the state, which requires re-evaluating only the derived predicates inferredB, inferredAB, and inferredBB.
Derived graph pruning by action. To optimize the evaluation of derived predicates during plan graph generation and runtime execution in PlanSys2, this work proposes appending the actions defined in the planning domain to the derived graph and pruning it to retain only the predicates relevant to the current action plan. For example, given the planning domain in Figure 3 and the plan , the derived graph shown in Figure 4a can be pruned to the graph in Figure 4b, avoiding the unnecessary resolution of predicates inferredAA and inferredBB.
Evaluation
This work evaluates PLANTA on two use cases from the literature: (i) the SUAVE exemplar [39], in which an AUV performs pipeline inspection, and (ii) an AGV scenario from Cámara et al. [13], in which the AGV navigates through an environment composed of corridors and rooms. The evaluation is organized around the following research questions:
RQ1 (Feasibility). Can PLANTA be integrated into a ROS 2-based robotic system to perform task and architecture co-adaptation at runtime, and how does its mission performance compare with that of existing managing subsystems?
RQ2 (Performance efficiency). How do PLANTA’s planning time and peak memory usage compare with those of the approach by Cámara et al. [13], and does PLANTA produce plans of comparable quality?
RQ3 (Scalability). How does PLANTA’s planning time evolve as the mission and adaptation spaces grow, and what are the trade-offs between optimal and satisficing planning?
RQ1 is addressed by the implementation of PLANTA and its integration with PlanSys2 (§ 7), and by applying PLANTA to the SUAVE exemplar and its TACA extension (§ 8.1), which primarily serve as a feasibility evaluation. RQ2 is addressed with the AGV scenario (§ 8.2). RQ3 is addressed by varying the AGV scenario along four dimensions, independently and in combination (§ 8.3). For all scenarios, the size of the planning instance is reported in terms of the number of task and reconfiguration actions, derived predicates, objects, and initial facts, to characterize the complexity of PLANTA’s planning formulations (Table 2). The complete source code and experimental artifacts are publicly available online for the SUAVE experiments [38] and the navigation experiments [37].
| Scenario | Task actions | Reconfig. actions | Objects | Init. facts | Derived predicates |
| SUAVE | 3 | 2 | 44 | 115 | 54 |
| SUAVE extended | 4 | 2 | 49 | 125 | 55 |
| Navigation | 1 | 2 | 537 | 3184 | 53 |
| 1 | 2 | 947 | 8878 | 53 | |
| 1 | 2 | 150 | 1012 | 53 | |
| 1 | 2 | 144 | 1561 | 53 | |
| 5 | 2 | 153 | 988 | 53 | |
| 5 | 2 | 173 | 1635 | 53 |
Table 2. Complexity of the planning instances. Task actions: PDDL actions encoding each task in the mission. Reconfig. actions: PDDL actions encoding architecture reconfiguration. Objects: domain constants and problem-instance objects. Init. facts: ground atoms in the initial state. Derived predicates: predicates generated by Owl2PDDL from the ontology. The scalability instances are reported at the maximum tested parameter value (: 900 nodes, : 15 architectural configurations, : 4 corridor types, : 5 mission-level actions, and : 90 nodes).
SUAVE exemplar
Experimental design. To assess PLANTA’s feasibility, mission performance, and reaction time, it is applied to the SUAVE exemplar (see § 2) and its TACA extension.
To support the benchmarking of different adaptation approaches, the SUAVE system is structured into a managing and a managed subsystem. The managing subsystem, responsible for the adaptation logic, can be replaced by any self-adaptive system that complies with the provided interfaces. SUAVE is packaged with three distinct managing subsystems: one that arbitrarily selects configurations, a behavior tree-based one, and Metacontrol [9]. Additionally, Silva et al. [40] made a ROSA implementation of SUAVE and its extended version available.
To apply PLANTA to SUAVE, this work proposes a PDDL-TOMASys model of the SUAVE exemplar based on the SUAVE TOMASys ontology. The main differences are the addition of new actions, utility rules, and a rule to handle uncertainty U2 (water visibility). First, the actions search pipeline and inspect pipeline, as well as their functional requirements, are added to the SUAVE ontology. For the extended use case the recharge battery action is also included. For example, requiresF relates search pipeline to the functions maintain motion and generate search path. Then, rules are added to infer the Functions utility, for example, a rule that instantiates the generic (utility) rule of § 5 for the generate search path function. Finally, the following rule is defined to infer whether the generate search path function designs are realizable, given the measured water visibility:
To exemplify the output of the model transformation process, Listing 4 shows the final PDDL formulation for the search pipeline action from the SUAVE use case. The SUAVE task actions in Table 2 include the non-managed action of starting the robot. The extended instance adds one extra PDDL action schema, recharge battery, and one derived predicate that encodes the battery level condition for uncertainty U3.
Experimental Setup. To compare PLANTA with existing adaptation approaches, it was evaluated on both the original and extended SUAVE use cases. To reduce the risk of bias from a single parameter set, as in [39, 40], the evaluation used randomized values for the robot’s initial position, the water visibility shift (i.e., its initial value), and the timing of thruster failures. Specifically, three experiments were conducted for each use case, each with a distinct parameter configuration as detailed in Table 3.
| Exp. | Initial position Y | Water visibility Min (m) | Water visibility Max (m) | Water visibility Period (s) | Water visibility Shift (s) | Thruster failures Thruster | Thruster failures Time (s) |
| 1 | 2.5 | 2.5 | N/A | N/A | 1 and 3 | ||
| 2 | 1.25 | 3.75 | 120 | N/A | N/A | ||
| 3 | 1.25 | 3.75 | 120 | 1 and 3 |
Table 3. Parameter configuration for the SUAVE experiments, where is a random uniform distribution from to . The initial position is relative to the Gazebo reference frame, where is fixed at and at . The time limit for each execution is set to 250 seconds.
The original use case was executed 30 times with no managing subsystem, as well as with each of the following managing subsystems: a random subsystem, a behavior-tree-based subsystem (BT), Metacontrol, ROSA, and PLANTA.
The extended scenario, which includes TACA, was also executed 30 times for the BT-based subsystem, ROSA, and PLANTA. In both the original and the extended scenarios, Fast Downward was configured to use search with the blind heuristic for PLANTA. To ensure that outliers were averaged out, the parameters were kept the same for each group of five runs (i.e., runs 1–5, 6–10, etc.) within the 30 runs. For each run, standard SUAVE metrics [39] were collected: pipeline search time, the time from mission start until the AUV locates the pipeline, and pipeline distance inspected, the total length of pipeline inspected during the mission. A third metric, reaction time [40], was also collected: the time elapsed from a constraint violation until the managing system completes adaptation of the managed subsystem.
Results. The experimental results for the SUAVE use case are presented in Table 4 and for the extended use case in Table 5. To verify whether there is a statistically significant difference between the results, the Wilcoxon signed-rank test was applied to all pairs of managing subsystems for both the pipeline search time and pipeline distance inspected metrics. The p-values for experiment 3 and extended experiment 3, which combine thruster failures and water visibility changes, are reported in Table 6. The p-values for the remaining experiments are reported in the appendix.
| Exp. | Managing subsystem | Search time (s) Mean | Search time (s) Std. dev. | Distance inspected (m) Mean | Distance inspected (m) Std. dev. | Mean reaction time (s) | Mean reaction time (s) |
| 1 | None | 58.77 | 26.07 | 49.50 | 12.56 | N/A | N/A |
| 1 | Random | 126.71 | 52.90 | 11.65 | 10.08 | N/A | N/A |
| 1 | BT | 59.63 | 27.46 | 58.17 | 8.43 | 0.07 | N/A |
| 1 | Metacontrol | 59.20 | 25.50 | 58.92 | 8.63 | 1.11 | N/A |
| 1 | ROSA | 65.33 | 27.48 | 57.76 | 9.06 | 0.75 | N/A |
| 1 | PLANTA | 65.07 | 33.95 | 43.56 | 8.77 | 0.88 | N/A |
| 2 | None | 152.13 | 30.32 | 27.31 | 11.23 | N/A | N/A |
| 2 | Random | 113.32 | 48.30 | 10.91 | 8.15 | N/A | N/A |
| 2 | BT | 83.83 | 30.96 | 50.42 | 10.25 | N/A | 0.13 |
| 2 | Metacontrol | 85.53 | 31.51 | 50.22 | 10.37 | N/A | 1.37 |
| 2 | ROSA | 89.03 | 31.19 | 49.69 | 10.46 | N/A | 1.52 |
| 2 | PLANTA | 87.83 | 31.41 | 44.45 | 10.11 | N/A | 1.78 |
| 3 | None | 148.97 | 33.14 | 25.90 | 9.47 | N/A | N/A |
| 3 | Random | 119.50 | 52.35 | 8.76 | 7.31 | N/A | N/A |
| 3 | BT | 84.43 | 30.94 | 49.82 | 10.30 | 0.07 | 0.12 |
| 3 | Metacontrol | 86.77 | 31.48 | 49.30 | 10.08 | 1.22 | 1.52 |
| 3 | ROSA | 89.57 | 31.71 | 49.31 | 10.53 | 0.78 | 1.56 |
| 3 | PLANTA | 88.73 | 32.07 | 43.58 | 9.45 | 1.45 | 1.86 |
Table 4. SUAVE results. The Random managing subsystem found the pipeline in 21/30 runs (70.00%) for Experiment 1, 22/30 runs (73.33%) for Experiment 2, and 22/30 runs (73.33%) for Experiment 3. All other managing subsystems found the pipeline in every run. Search time and inspected distance report the mean and sample standard deviation only for runs that found the pipeline. denotes thruster failure and water visibility. Reaction times are arithmetic means of recorded events per uncertainty across all retained runs. N/A denotes an inapplicable metric or insufficient observations. The initial visibility adjustment in Experiment 1 is excluded.
Table 5. SUAVE extended results. All managing subsystems found the pipeline in every run. Search time and inspected distance report the mean and sample standard deviation only for runs that found the pipeline. denotes thruster failure and water visibility, with denoting battery level. Reaction times are arithmetic means of recorded events per uncertainty across all retained runs. N/A denotes an inapplicable metric or insufficient observations. The initial visibility adjustment in Experiment 1 is excluded.
| Exp. | Managing subsystem | Search time (s) Mean | Search time (s) Std. dev. | Distance inspected (m) Mean | Distance inspected (m) Std. dev. | Mean reaction time (s) | Mean reaction time (s) | Mean reaction time (s) |
| 1 | BT | 64.30 | 34.37 | 23.40 | 8.17 | 0.09 | N/A | 1.09 |
| 1 | ROSA | 61.10 | 24.85 | 22.41 | 6.95 | 0.81 | N/A | 1.95 |
| 1 | PLANTA | 71.47 | 37.23 | 17.47 | 8.79 | 0.89 | N/A | 1.44 |
| 2 | BT | 83.93 | 30.88 | 16.74 | 9.09 | N/A | 0.12 | 1.08 |
| 2 | ROSA | 88.70 | 31.50 | 15.40 | 8.96 | N/A | 1.57 | 2.03 |
| 2 | PLANTA | 88.20 | 31.86 | 14.72 | 8.44 | N/A | 2.37 | 2.25 |
| 3 | BT | 89.07 | 40.14 | 16.25 | 9.07 | 0.07 | 0.12 | 1.07 |
| 3 | ROSA | 88.10 | 31.71 | 15.48 | 8.96 | 0.76 | 1.67 | 1.96 |
| 3 | PLANTA | 89.30 | 32.06 | 14.29 | 8.47 | 1.57 | 2.40 | 2.31 |
Table 5.
Table 6. Paired Wilcoxon signed-rank comparisons for experiment 3 and extended experiment 3. Each cell reports the unadjusted p-values for the comparison between the managing subsystem in the row and the one in the column for both the pipeline search time and pipeline distance inspected metrics. Cells with a green background indicate that the alternative hypothesis was favored, and cells with a blue background indicate that the null hypothesis cannot be rejected in favor of the alternative hypothesis. Values rounding to 0.000 are shown as < 0.001. “MC” stands for Metacontrol.
| Managing subsystem | Pipeline search time: None | Pipeline search time: Random | Pipeline search time: BT | Pipeline search time: MC | Pipeline search time: ROSA | Pipeline search time: PLANTA | Pipeline distance inspected: None | Pipeline distance inspected: Random | Pipeline distance inspected: BT | Pipeline distance inspected: MC | Pipeline distance inspected: ROSA | Pipeline distance inspected: PLANTA |
| None | - | 0.975 | 1.000 | 1.000 | 1.000 | 1.000 | - | < 0.001 | 1.000 | 1.000 | 1.000 | 1.000 |
| Random | 0.025 | - | 0.984 | 0.954 | 0.942 | 0.963 | 1.000 | - | 1.000 | 1.000 | 1.000 | 1.000 |
| BT | < 0.001 | 0.016 | - | < 0.001 | < 0.001 | < 0.001 | < 0.001 | < 0.001 | - | 0.093 | 0.084 | < 0.001 |
| MC | < 0.001 | 0.046 | 1.000 | - | < 0.001 | 0.001 | < 0.001 | < 0.001 | 0.907 | - | 0.457 | < 0.001 |
| ROSA | < 0.001 | 0.058 | 1.000 | 1.000 | - | 0.922 | < 0.001 | < 0.001 | 0.916 | 0.543 | - | < 0.001 |
| PLANTA | < 0.001 | 0.037 | 1.000 | 0.999 | 0.078 | - | < 0.001 | < 0.001 | 1.000 | 1.000 | 1.000 | - |
(a) Experiment 3
| Managing subsystem | Pipeline search time: BT | Pipeline search time: ROSA | Pipeline search time: PLANTA | Pipeline distance inspected: BT | Pipeline distance inspected: ROSA | Pipeline distance inspected: PLANTA |
| BT | - | < 0.001 | < 0.001 | - | < 0.001 | < 0.001 |
| ROSA | 1.000 | - | 0.621 | 1.000 | - | < 0.001 |
| PLANTA | 1.000 | 0.379 | - | 1.000 | 1.000 | - |
(b) Extended experiment 3
Table 6.
Results were paired by run index, and pairs in which either system did not find the pipeline were excluded from both comparisons. For each metric, the alternative hypothesis is that the managing system in the row achieves a lower pipeline search time or, respectively, a greater pipeline distance inspected than the one in the column. p-values less than 0.05 indicate statistical significance in favor of the alternative hypothesis.
SUAVE experiments: Across the three SUAVE experiments (Table 6a and Table 9 and Table 10), the BT managing subsystem achieved significantly lower pipeline search times than all other configurations. Metacontrol achieved significantly lower search times than ROSA and PLANTA in every experiment. PLANTA achieved significantly lower search times than ROSA in experiment 2, while no statistically significant difference between them was detected in experiments 1 and 3. For pipeline distance inspected, BT, Metacontrol, and ROSA each achieved significantly greater distances than PLANTA in all three experiments. PLANTA achieved significantly greater inspected distances than Random in every experiment. Compared with the configuration without a managing subsystem, PLANTA inspected significantly less pipeline distance in experiment 1 and significantly more in experiments 2 and 3.
| Managing subsystem | Pipeline search time | Pipeline distance inspected | ||||||||||
| None | Random | BT | MC | ROSA | PLANTA | None | Random | BT | MC | ROSA | PLANTA | |
| None | - | < 0.001 | 0.997 | 0.013 | < 0.001 | < 0.001 | - | < 0.001 | 1.000 | 1.000 | 1.000 | 0.010 |
| Random | 1.000 | - | 1.000 | 1.000 | 0.999 | 0.999 | 1.000 | - | 1.000 | 1.000 | 1.000 | 1.000 |
| BT | 0.003 | < 0.001 | - | 0.001 | < 0.001 | < 0.001 | < 0.001 | < 0.001 | - | 0.767 | 0.241 | < 0.001 |
| MC | 0.987 | < 0.001 | 0.999 | - | < 0.001 | 0.016 | < 0.001 | < 0.001 | 0.233 | - | 0.015 | < 0.001 |
| ROSA | 1.000 | 0.001 | 1.000 | 1.000 | - | 0.846 | < 0.001 | < 0.001 | 0.759 | 0.985 | - | < 0.001 |
| PLANTA | 1.000 | 0.001 | 1.000 | 0.984 | 0.154 | - | 0.991 | < 0.001 | 1.000 | 1.000 | 1.000 | - |
Table 9. Experiment 1: paired Wilcoxon signed-rank comparisons.
| Managing subsystem | Pipeline search time | Pipeline distance inspected | ||||||||||
| None | Random | BT | MC | ROSA | PLANTA | None | Random | BT | MC | ROSA | PLANTA | |
| None | - | 0.997 | 1.000 | 1.000 | 1.000 | 1.000 | - | < 0.001 | 1.000 | 1.000 | 1.000 | 1.000 |
| Random | 0.003 | - | 0.999 | 0.994 | 0.960 | 0.974 | 1.000 | - | 1.000 | 1.000 | 1.000 | 1.000 |
| BT | < 0.001 | 0.001 | - | < 0.001 | < 0.001 | < 0.001 | < 0.001 | < 0.001 | - | 0.333 | 0.052 | < 0.001 |
| MC | < 0.001 | 0.006 | 1.000 | - | < 0.001 | < 0.001 | < 0.001 | < 0.001 | 0.667 | - | 0.104 | < 0.001 |
| ROSA | < 0.001 | 0.040 | 1.000 | 1.000 | - | 0.988 | < 0.001 | < 0.001 | 0.948 | 0.896 | - | < 0.001 |
| PLANTA | < 0.001 | 0.026 | 1.000 | 1.000 | 0.012 | - | < 0.001 | < 0.001 | 1.000 | 1.000 | 1.000 | - |
Table 10. Experiment 2: paired Wilcoxon signed-rank comparisons.
SUAVE extended experiments: Across the three extended SUAVE experiments (Table 6b and Table 11 and Table 12), the BT managing subsystem achieved significantly lower pipeline search times than ROSA and PLANTA, while no statistically significant difference in search time was detected between ROSA and PLANTA. For pipeline distance inspected, BT achieved significantly greater distances than both ROSA and PLANTA, and ROSA achieved significantly greater distances than PLANTA in every experiment.
| Managing subsystem | Pipeline search time | Pipeline distance inspected | ||||
| BT | ROSA | PLANTA | BT | ROSA | PLANTA | |
| BT | - | 0.001 | < 0.001 | - | 0.002 | < 0.001 |
| ROSA | 0.999 | - | 0.352 | 0.998 | - | < 0.001 |
| PLANTA | 1.000 | 0.648 | - | 1.000 | 1.000 | - |
Table 11. Extended experiment 1: paired Wilcoxon signed-rank comparisons.
| Managing subsystem | Pipeline search time | Pipeline distance inspected | ||||
| BT | ROSA | PLANTA | BT | ROSA | PLANTA | |
| BT | - | < 0.001 | < 0.001 | - | < 0.001 | < 0.001 |
| ROSA | 1.000 | - | 0.862 | 1.000 | - | < 0.001 |
| PLANTA | 1.000 | 0.138 | - | 1.000 | 1.000 | - |
Table 12. Extended experiment 2: paired Wilcoxon signed-rank comparisons.
Answer to RQ1: These results support the feasibility of using PLANTA for runtime task and architecture co-adaptation in SUAVE, but also reveal limitations in mission performance. BT, Metacontrol, and ROSA each achieved significantly better results than PLANTA on at least one metric in every experiment in which they were evaluated. PLANTA performed significantly better than Random on both metrics in all original experiments, and better than the configuration without a managing subsystem in experiments 2 and 3, but worse in experiment 1. BT’s shorter mean reaction times (Table 4 and Table 5) may partly explain its advantage, although the experiments do not establish a causal relationship between reaction time and mission performance.
Navigation use case
Experimental design. To evaluate PLANTA’s performance efficiency, in terms of planning time and peak resident set size (RSS) memory usage, and its plan quality, it was applied to the navigation scenario from [13]. Results were compared to those obtained from a replicated implementation of the algorithm proposed in [13], hereafter referred to as Camara. In the scenario, a robot must navigate from an initial position to a goal position within an environment composed of corridors and rooms. Some corridors might be dark or contain obstacles, reducing their safety. During navigation, the robot dynamically adapts both its architecture (i.e., the sensors and localization algorithms employed) and its task execution (i.e., the path followed) to circumvent failures or prioritize safety or energy consumption. For example, if the robot’s planned path includes a dark corridor and its lamp fails during execution, it must reconfigure its architecture and adapt its task execution to avoid dark corridors.
Experimental setup. To compare PLANTA’s time performance and memory usage with Camara, the map from [13] was discretized to ensure uniform edge lengths. This change was necessary because PLANTA does not support numeric fluents and therefore cannot handle edges of varying sizes (§ 9.4). PLANTA was then applied to perform task and configuration planning on the discretized map. For this comparison, Fast Downward was configured to use eager greedy search with the goal-count heuristic.
Additionally, a model generator was developed to produce PRISM models equivalent to those used in the final step of Camara5, enabling policy generation for task planning and reconfiguration. A minor correction was introduced to the original PRISM model by adding an effect to the move actions, allowing the selection of distinct configurations for each corridor. This work assumes that the correction aligns with the authors’ original intent, as the published model appears to contain a typographical error. For all experiments, PRISM was executed with the goal of maximizing the amount of battery remaining at the end of the mission. Both approaches were evaluated by applying them ten times to all possible combinations of initial and goal locations.
Results. Figure 5 shows that, at the median, PLANTA generates both task and configuration plans 3.00 times faster than Camara generates the corresponding policy from the PRISM models, with 6.84 times smaller peak memory usage. In the scenarios with the worst planning time, PLANTA (from location 16 to 25) takes 0.56 seconds with 66.88 MiB peak memory usage, compared to 13.71 seconds with 4089.03 MiB peak memory usage for Camara (from location 52 to 24). Notably, the spread of execution times and memory consumption is much higher for Camara, making the resources required by PLANTA more predictable. These results should be interpreted as a comparison of the computational cost of two different ways of addressing TACA rather than as a direct comparison of approaches that pursue the same objective. Camara seeks an optimal task and configuration policy under probabilistic uncertainty, whereas PLANTA favors satisficing planning over mission-level optimality, planning from the currently observed state and handling changes during execution through replanning.

(a) Planning time comparison between PLANTA and Camara.

(b) Peak RSS memory comparison between PLANTA and Camara.
Figure 5. Comparison between PLANTA and Camara. The number is the median value, the boxes show interquartile range (Q1–Q3), the whiskers reach until ±1.5 IQR, and the circles show a sample of the observations beyond the whiskers.
Despite the difference in planning time and memory usage, the two approaches produce plans with almost identical path length and remaining battery. The distributions of distance traveled and of the numbers of move and reconfiguration actions nearly coincide. For example, the interquartile range of distance traveled is 36.81 to 82.70 for PLANTA and 36.62 to 82.66 for Camara, with the same median of 59.89. The median remaining battery differs by only 1.02% (25219.50 for PLANTA against 25480.00 for Camara). Both approaches reconfigure more than once in a minority of the scenarios, 11.85% for PLANTA and 15.52% for Camara, and up to four times (for example, between locations 11 and 17 for PLANTA and between locations 5 and 18 for Camara).
The reported computational performance difference likely underestimates PLANTA’s advantage. In [13], the final step, the sole component that could be reproduced for Camara, accounts for only 39.34% of the total execution time. Furthermore, Camara generates and verifies PRISM models for the ten best paths between the initial and goal locations, selecting the best policy according to a predefined utility function. In contrast, the experiment described in this paper generates and verifies a PRISM model only for the single best path.
Answer to RQ2: In the evaluated AGV scenario, PLANTA addresses TACA at a lower computational cost than the replicated final step of Camara, in both planning time and peak memory usage, while producing plans with almost identical path length and remaining battery.
Scalability
Experimental design. To assess the scalability of the proposed approach with respect to mission and adaptation spaces, in terms of planning time and memory usage, five additional experiments were conducted using variations of the previous navigation scenario. Specifically, four experiments were designed to independently evaluate the effect of varying the map size, the number of architectural configurations, the number of quality requirements, and the number of task actions. A fifth experiment was designed to stress-test the approach by varying the map size while fixing all other parameters at their maximum values.
Furthermore, to isolate the effect of the adaptation logic on planning time and memory usage, each of the scalability experiments described above was also conducted using only the mission logic (i.e., without reconfiguration). In addition, to compare optimal and satisficing planning, all scalability experiments, both with and without the adaptation logic, were repeated with Fast Downward configured to use A* search with the blind heuristic and eager greedy search with the goal-count heuristic, where an optimal plan corresponds to the shortest plan since all actions have unit cost.
Experimental setup. For each scalability experiment, a map generator produces grid-like maps with the required number of nodes, edges, and corridor types. The generator skips 10% of nodes and 15% of the edges are removed while preserving graph connectivity. In the baseline maps, 25% of the corridors are marked as dark and 25% are marked as unsafe. The generated map is then translated into a PDDL problem file, leveraging the Unified Planning [32] library, with node 0 as the robot’s initial position and the highest-indexed node as the goal waypoint. Figure 6 shows an example map. Each experiment is repeated 10 times for each search strategy (i.e., A* and eager greedy) and adaptation mode (with and without adaptation), while the planning time, peak memory usage, and the number of actions in the plan are collected.

Figure 6. Grid map example with 45 retained nodes out of 50 generated nodes. White edges represent normal corridors, filled edges represent dark corridors and curved edges represent unsafe corridors. The initial location is marked with I and the goal location is marked with G.
Table 7 lists the parameter ranges of the five scalability experiments. Architectural configurations are combinations of sensors and localization algorithms, and S2 adds further combinations.6 S3 models additional quality requirements as two new corridor types: outdoor corridors (20%) and dusty corridors (20%). Outdoor corridors require sensors that are robust to sunlight, for example, lidars, whereas dusty corridors require sensors that are robust to floating particles, for example, RGB cameras. S4 adds the mission-level PDDL actions inspect, deliver, recharge, and report. The map-size upper bound in S5 is lower than in S1 because S5 combines the largest architectural configuration space, the largest set of corridor requirements, and the largest mission-action set, which substantially increases the planning space. Experiments S2, S3, and S4 use maps with 100 nodes, so that changes in planning time and memory usage can be interpreted primarily with respect to the dimension varied in each experiment rather than map size, which is evaluated separately in S1. S5 combines the action-driven configuration growth of S4 with the additional architectural configurations introduced in S2, yielding 23 configurations. The configurations added in S4 are intentionally not ranked by utility, which avoids introducing a separate utility-optimization factor into the mission-action scalability experiment. Table 2 reports the resulting complexity of each experiment’s planning instance at its maximum tested parameter value.
| Experiment | Map nodes | Arch. configs | Corridor types | Actions |
| S1 Map size | 10–1000, step 10 | 6 | 2 | 1 |
| S2 Arch. configurations | 100 | 2, 4, 6, 8, 10, 12, 15 | 2 | 1 |
| S3 Quality requirements | 100 | 6 | 2, 3, 4 | 1 |
| S4 Mission-level actions | 100 | 6–14 | 2 | 1, 2, 3, 4, 5 |
| S5 Combined (stress test) | 10–100, step 10 | 23 | 4 | 5 |
Table 7. Parameter configurations for the five scalability experiments (S1–S5). Map nodes are generated nodes. The map generator skips 10% of them, so the maximum of 1000 generated nodes in S1 and 100 in S5 corresponds to 900 and 90 retained nodes, respectively. For S4 and S5, the number of architectural configurations grows with the number of action types: each additional mission-level PDDL action introduces two further configurations.
Results. Across the five scalability experiments, the number of mission-level PDDL actions is the dominant driver of planning time, with map size as a secondary driver. Architectural configurations (S2) and quality requirements (S3) have a small effect on planning time. Map size (S1) produces a moderate increase for both search strategies, whereas increasing the number of mission-level PDDL actions (S4) leads to a much larger increase, with search requiring more than an order of magnitude more time than eager greedy search while both strategies produce plans of similar length. This disparity becomes even more pronounced when all dimensions are combined (S5), where search becomes impractical for online TACA, while eager greedy search remains manageable. Peak memory usage grows mainly with map size and, for search, with the number of mission-level PDDL actions. It ranges from 37.69 MiB to 104.66 MiB in S1 and reaches 308.43 MiB for search and 90.32 MiB for eager greedy search in the largest S5 instances. Table 8 summarizes the results, and Figure 7 shows the planning-time trends of S1, S4, and S5. The plots for all five experiments, including plan length, are given in Figure 8 to Figure 12 of the appendix.
| Exp. | Planning time (s) Mean | Planning time (s) Std. | Plan length Mean | Plan length Std. | Eager greedy Planning time (s) Mean | Eager greedy Planning time (s) Std. | Eager greedy Plan length Mean | Eager greedy Plan length Std. |
| S1 | 0.92 | 0.02 | 47.20 | 7.74 | 0.95 | 0.03 | 47.20 | 7.74 |
| S2 | 0.30 | 0.00 | 20.70 | 1.42 | 0.30 | 0.02 | 20.70 | 1.42 |
| S3 | 0.20 | 0.00 | 20.30 | 2.26 | 0.20 | 0.00 | 20.30 | 2.26 |
| S4 | 15.45 | 1.24 | 46.00 | 5.52 | 1.05 | 0.30 | 46.80 | 6.21 |
| S5 | 188.96 | 20.43 | 48.10 | 3.73 | 13.73 | 3.66 | 51.60 | 5.64 |
Table 8. Scalability experiment results at the maximum tested parameter value for each experiment (S1: 900 nodes, S2: 15 architectural configurations, S3: 4 corridor types, S4: 5 mission-level actions, and S5: 90 nodes).

Figure 7. Planning time in the scalability experiments , , and . The shaded area shows the standard deviation. EG stands for the eager greedy search.

Figure 8. (a) Planning time as map size increases. (b) Plan length as map size increases. Both search strategies overlap.

Figure 12. S5 results: Planning time and plan length as map size increases. The shaded area shows the standard deviation. EG stands for the eager greedy search.
S1: Map size. Figure 7a shows that the planning time increases with map size. For the largest maps, with 900 retained nodes, computing a plan takes less than one second with both search strategies (Table 8). This is adequate for non-safety-critical robotic applications in which replanning is not required at high frequency, such as the experiment’s navigation application. The and eager greedy curves are similar, indicating little difference between optimal and satisficing planning in this experiment. and eager greedy also result in plans with the same length (Table 8).
and : Architectural configurations and quality requirements. Planning time remains below 0.31 seconds over the evaluated range of architectural configurations and corridor types (Table 8). and eager greedy return plans with the same length.
: Mission-level PDDL actions. Figure 7b shows that planning time increases with the number of mission-level PDDL actions, especially for search. With 5 mission-level actions, requires 15.45 seconds on average, whereas eager greedy search requires 1.05 seconds. Table 8 also shows that this reduction in planning time does not come with a substantial increase in plan length. This latency matters for online TACA: in the navigation scenario, for example, a lamp failure before traversing a dark corridor requires replanning so that the resulting task plan and architectural configuration satisfy the corridor requirements. Therefore, eager greedy search is the more practical choice for online TACA in this scenario.
: Combined stress test. When the dimensions varied individually across – are combined, planning time increases substantially compared to varying map size alone. In , planning time reaches 188.96 seconds on average for search and 13.73 seconds on average for eager greedy search at just 90 retained nodes, as shown in Figure 7c. This represents an increase of 205.62 times in planning time relative to , for a map that is one-tenth the size (90 vs 900 retained nodes), confirming that combining all dimensions simultaneously amplifies planning time well beyond what any single-dimension experiment produces. Despite the difference in planning time between both search strategies, plan length has a modest difference (Table 8). For online TACA under the full-complexity configuration, eager greedy search is the more tractable option. Nevertheless, its planning time is still high for applications requiring frequent replanning.
No adaptation. Figure 7a and Figure 7b7 demonstrate that planning with only the mission logic (i.e., task planning) is substantially faster than planning with the adaptation logic included (i.e., task and architecture planning). For the single-action mission used in –, the no-adaptation baseline reaches approximately 0.15 seconds at 900 retained nodes. For the mission used in –, the no-adaptation baseline reaches approximately 0.10 seconds with five mission-level actions. These results indicate that the adaptation logic is the primary source of the planning-time increase observed with adaptation.
Answer to RQ3: The scalability experiments – show that planning time remains manageable as map size, the number of architectural configurations, and the number of quality requirements increase individually, for both satisficing and optimal planning. shows that increasing the number of mission-level PDDL actions has a substantially greater impact on planning time under optimal planning than under satisficing planning. Since both approaches produce plans of similar length, satisficing planning is the more suitable choice for this scenario. shows that, when all dimensions are combined, planning time reaches impractical levels under optimal planning and high, though potentially acceptable, levels under satisficing planning for non-safety-critical applications with low replanning frequency. Across all experiments, Table 2 shows that raw instance size, in objects and initial facts, is driven primarily by map size rather than by architectural or mission complexity, indicating that the planning-time increase observed in and stems from the added branching factor of additional PDDL action schemas rather than from a larger planning instance.
Discussion
This section discusses the SUAVE and navigation results, explains the choice of OWL rather than PDDL for modeling the system architecture, and examines the limitations of PLANTA.
SUAVE exemplar
The SUAVE experiments show that applying PLANTA to a ROS 2-based robotic exemplar is feasible, but they also reveal mission-performance limitations relative to the other managing subsystems evaluated. BT achieved lower pipeline search times and greater pipeline distances inspected than PLANTA across the original and extended experiments, and ROSA and Metacontrol also outperformed PLANTA on several mission-performance comparisons. Therefore, the SUAVE results should be interpreted primarily as evidence that PLANTA can be integrated with and executed on a realistic ROS 2-based robotic exemplar, rather than as evidence of mission-performance superiority. The SUAVE exemplar provides a concrete scenario and an experimental setup for evaluating whether managing systems can bridge the gap between theory and practice. The challenges involved in achieving this integration are often underestimated. As shown in § 7.2, integrating PLANTA with PlanSys2 required extending the PDDL features that PlanSys2 supports, adapting its plan-execution algorithms, and implementing a planner plugin, which introduced substantial engineering overhead.
At the same time, the SUAVE experiment highlights the need for new ROS 2-based exemplars for self-adaptive robotic systems that enable a more fine-grained evaluation of how overall mission quality is affected by performance efficiency, including scalability, reaction time, and memory usage.
Navigation use case
Although both PLANTA and the approach proposed by Cámara et al. [13] address TACA for the entire mission, they differ fundamentally in their underlying planning philosophy. PLANTA computes a satisficing task and configuration plan that selects the best configuration for each action based on a predefined utility function. In contrast, the approach by Cámara et al. seeks to generate an optimal task and configuration policy that maximizes the overall mission utility. Furthermore, PLANTA assumes deterministic action effects and configuration utilities, while the method of Cámara et al. models probabilistic outcomes, such as collision risks during execution.
In the experiment in § 8.2, the replicated final step of CÁMARA, which computes an optimal policy under a probabilistic model, required more planning time than PLANTA. Optimal planning can yield better results when the robot and its environment behave as modeled, but in dynamic environments the assumptions made at design time may not hold during operation. Under these conditions, it can be more advantageous to search for a satisficing solution, monitor during execution whether the current plan remains valid, and replan when it does not, because optimal planning is generally more expensive and therefore incurs a higher penalty at each replanning. A practical strategy could therefore be to use optimal planning for the initial mission plan and satisficing planning for runtime replanning.
Modeling the System Architecture in OWL
There are three main reasons why the robotic system and its functional designs are modeled in OWL rather than directly in PDDL.
First, although PDDL supports type hierarchies, OWL offers substantially richer mechanisms for representing class axioms, relations, and inferred knowledge. In PDDL, objects are assigned a type, and type membership follows from explicitly declared type hierarchies. This limits the representation of relationships between classes, which is particularly relevant for robotic components. For example, a specific camera model can be represented as a camera, a visual sensor, and a device requiring electrical power, but these relationships must be explicitly encoded in the type hierarchy. Moreover, it remains unclear whether PDDL types can be treated as predicates [19]. In contrast, OWL allows classes to be defined independently and related through axioms, enabling class membership to be inferred rather than explicitly declared. For example, a device requiring electrical power can be defined as any component with a power-consumption property, allowing camera models with this property to be classified accordingly. Together with SWRL rules, OWL also supports inferring relations that are not explicitly asserted. PLANTA relies on these inference capabilities to determine which FunctionDesigns can ground a Function and which FunctionDesign has higher utility, as described in § 5. These modeling capabilities are particularly valuable for representing robotic systems and are extensively used in PLANTA.
Secondly, there exist many tools for OWL ontologies that assist in modeling classes and their relationships, including the SWRL rules used in this work for inference. These tools allow automatic checking of the model for common errors, such as verifying the consistency of class descriptions and ensuring that instances of the classes can exist without violating other axioms (i.e., satisfiability). In addition, they can visualize the class structure, which further facilitates model development.
Lastly, established standards exist for representing robotic systems and their components using ontologies, such as the IEEE Standard for Autonomous Robotics (AuR) ontology [25]. No equivalent standards are known to exist for PDDL. Therefore, modeling with OWL ontologies increases the likelihood of producing reusable and interoperable models.
Limitations
A limitation of PLANTA is that it evaluates architectural alternatives locally, i.e., for each Function required by an action, it selects the realizable FunctionDesign with the highest utility with respect to that Function. This selection should not be interpreted as mission-level utility optimization. For example, an architectural configuration that provides better performance for an individual function may consume significantly more energy throughout the mission, yet PLANTA would still select it. In domains where architectural choices have long-term effects, such as energy consumption or resource depletion, accounting for such trade-offs would require explicitly modeling their mission-level consequences and incorporating an appropriate optimization objective.
A further limitation concerns the costs associated with architectural reconfiguration. Although reconfiguration is represented through planning actions, the current formulation does not model transition-related costs, such as reconfiguration duration and energy consumption. Consequently, the resulting plans may overlook relevant overhead associated with changing architectural configurations. These aspects could be incorporated by extending the planning model with temporal or cost-aware features, such as durative actions or action costs.
Another limitation of PLANTA is its reliance on PDDL derived predicates, a feature not supported by most PDDL-based planners, limiting the number of planners that can be used with PLANTA. More specifically, to the best of our knowledge, no existing planner supports both derived predicates and numeric fluents. This poses a significant constraint in the robotics domain, where numeric modeling is essential for representing properties such as battery level, power consumption, and distance.
To mitigate this limitation, the proposed Owl2PDDL transformation encodes numerical values as symbolic constants and explicitly represents inequality relations among them. This enables symbolic reasoning over “numeric” values using inequalities. However, it does not support traditional numerical planning as defined in PDDL 2.1 [17], which involves arithmetic operations and numeric fluents.
This work nevertheless keeps derived predicates explicit in the planning domains of PLANTA, because compiling them away can, in the worst case, cause an exponential blow-up in the size of the domain formulation or in the length of the shortest plans [43].
Threats to Validity
Construct validity. The comparison with Camara involves different planning guarantees: an optimal policy under probabilistic uncertainty versus a satisficing deterministic plan with replanning (§ 9.2). The plan-quality comparison shows that, on the evaluated instances, both approaches produced plans with near-identical path length and estimated remaining battery. However, these metrics are computed for nominal execution and do not capture how each approach performs when probabilistic events, such as collisions, occur. Moreover, only the final step of the approach of Cámara et al. was replicated. As discussed in § 8.2, the reported computational performance difference therefore likely underestimates the advantage of PLANTA.
Internal validity. Planner choice and planner configuration influence planning time. PLANTA uses Fast Downward in all experiments because it supports the derived predicates and existential preconditions required by the generated planning models (§ 7.2), and other planners or search configurations may yield different planning times. To expose this effect, the scalability experiments compare search with the blind heuristic and eager greedy search with the goal-count heuristic, each with and without the adaptation logic (§ 8.3). To reduce the effect of random variation, the navigation and scalability experiments were repeated ten times. Each SUAVE experiment was executed 30 times per managing subsystem, with randomized parameters drawn for each group of five consecutive runs (Table 3), and differences between managing subsystems were assessed with the Wilcoxon signed-rank test. All source code and experimental artifacts are publicly available to support replication.
External validity. The evaluation covers only two use cases and therefore does not establish that the results generalize to other robotic systems. Both use cases come from the literature and were originally introduced to evaluate other self-adaptation approaches, which reduces the risk of selecting scenarios that favor PLANTA. Moreover, – are synthetic variations of the navigation use case. They use generated grid maps and, depending on the experiment, synthetic corridor types, mission-level PDDL actions, or additional architectural configurations that do not model realistic selection criteria. Their results therefore characterize planning-time trends for grid-map navigation missions within the tested parameter ranges (Table 7). The SUAVE experiments were executed in the Gazebo simulator rather than on a physical vehicle, so they do not capture the behavior of PLANTA on a physical AUV. All managing subsystems were evaluated in the same simulated setup, which keeps their comparison consistent. Finally, PLANTA does not support PDDL numeric fluents (§ 9.4), and the navigation map was discretized to uniform edge lengths, so the results do not extend to problems that require numerical planning.
Conclusion and Future Work
This paper presented PLANTA, an ontology-mediated approach to task and architecture co-adaptation that integrates architectural knowledge represented in OWL with task planning problems defined in PDDL. By automatically combining these models, PLANTA enables joint planning of task and reconfiguration actions using satisficing planning, with replanning when changes during execution invalidate the current plan. An open-source ROS 2 implementation of the approach is provided, including extensions to PlanSys2 to support the PDDL features required for planning and plan execution.
The evaluation in the SUAVE underwater inspection scenario supports the feasibility of runtime co-adaptation, although it also reveals mission-performance limitations relative to other managing subsystems. In the ground navigation scenario, PLANTA required less planning time and peak memory than the replicated final step of the approach by Cámara et al. [13], while producing plans with similar path length and estimated remaining battery. However, these approaches pursue different planning objectives, with PLANTA computing satisficing plans and Cámara et al. generating optimal policies under probabilistic uncertainty. The scalability experiments further showed that planning time remains manageable as map size, architectural configurations, or quality requirements increase individually, but grows substantially with additional mission-level actions under optimal planning and when multiple problem dimensions are combined. In these more complex scenarios, satisficing planning remained tractable where optimal planning became impractical, although its planning time in the combined scenario remained high for applications requiring frequent replanning. These results indicate that, in the evaluated scenarios, satisficing planning with runtime replanning is a practical alternative to optimal policy generation for task and architecture co-adaptation. Future work includes addressing the limitations discussed in § 9.4: selecting architectural alternatives with respect to mission-level objectives rather than per function, modeling reconfiguration costs through action costs or durative actions, and supporting numeric quality attributes without symbolic encoding. Further directions include applying PLANTA to diverse real-world robotic systems to assess its reusability and further identify its limitations. Another promising direction is exploring the integration of the proposed planning approach into existing reference architectures for robot self-adaptation, such as ROSA [40].
Acknowledgments
This work was supported by the European Union’s Horizon 2020 Framework Programme through the MSCA network REMARO (Grant Agreement No 956200); Horizon Europe CoreSense (no. 101070254); and Proyectos de Generación de Conocimiento 2021 call of Ministry of Science and Innovation of Spain co-funded by the European Union, project PID2021-126592OB-C22 CASCAR/DMARCE.
Algorithms of the PlanSys2 extensions
This section details the algorithms of the PlanSys2 extensions described in § 7.2.
To support the evaluation of existential preconditions and derived predicates in PlanSys2, this work proposes the evaluation algorithm described in Algorithm 1. Lines 2-3 evaluate predicates by unifying their free parameters with all objects in that satisfy the predicate, returning a set of dictionaries of the form . Lines 4-6 solve negated conditions by evaluating the condition and returning the complement of the evaluated set with respect to the current state , with the form . Lines 7-13 evaluate conjunctions of conditions by individually evaluating each condition and joining the solution sets. Lines 14-17 evaluate disjunctions by evaluating each condition and merging the solution sets. Lines 18-20 evaluate existential preconditions by evaluating
Algorithm 1 Evaluation algorithm
1: procedure Evaluate(C, S)
2: if C = (p ?x₁ ... ?xₙ) then
3: return UnifyPredicate(C, S)
4: else if C = (not (C′)) then
5: E ← Evaluate(C′, S)
6: return ComplementSet(E, S)
7: else if C = (and (C′ ... C″)) then
8: E ← {∅}
9: for c ∈ {C′, ..., C″} do
10: E′ ← Evaluate(c, S)
11: E ← Join(E, E′)
12: end for
13: return E
14: else if C = (or (C′ C″)) then
15: E′ ← Evaluate(C′, S)
16: E″ ← Evaluate(C″, S)
17: return Union(E′, E″)
18: else if C = (exists (?xₑ₁ ... ?xₑₖ) C′) then
19: E ← Evaluate(C′, S)
20: return E \ {?xₑ₁, ..., ?xₑₖ}
21: end if
22: end procedure
their body and returning a dictionary without free variables in the form .
To solve derived predicates, this work introduces Algorithm 2. It partitions the resolution graph into acyclic and cyclic components. The acyclic components are resolved in topological order, while the cyclic components are resolved using a fixed-point iteration. Root nodes are considered solved by definition, as they correspond to non-derived predicates. For instance, in the graph shown in Figure 4a, the derived predicates inferredB and inferredAB form a cycle, whereas the other derived predicates are acyclic.
Line 2 calls the GetDerivedSCCs function, which computes the strongly connected components (SCCs) of the subgraph formed by traversing all descendant nodes of the Roots nodes in the resolution graph, using Tarjan’s algorithm [42]. The function returns a vector of SCCs in topological order. Each SCC contains only derived predicates, explicitly excluding predicates, functions, and instances. For example, if Roots = {predicateA, predicateB},
GetDerivedSCCs(Graph, Roots) = {{inferredA}, {inferredAA}, {inferredB, inferredAB}, {inferredBB}}.
Lines 4–15 solve the cyclic SCCs using a fixed-point iteration, while lines 17–22 handle each acyclic SCC by solving its single derived predicate. The Unground function removes all existing assertions of and its descendants from the state . The Evaluate function evaluates the preconditions of the derived predicate , storing all valid parameter bindings in the set (e.g., ). The GroundPredicates function grounds the derived predicate for each substitution in (e.g., (inferredA instance1)) and adds the resulting assertions to the state.
Algorithm 3 defines the ApplyEffects function. Its inputs are the current state , the effects Eff of an action, the resolution graph Graph, the set Nodes of modified nodes, and a boolean Derive that indicates whether derived predicates should be recomputed. Lines 2–4 add a predicate to the state, and lines 5–7 remove a negated predicate from
Algorithm 2 Derived Predicates Evaluation
1: procedure SolveDerived(Graph, Roots, S)
2: SCCs ← GetDerivedSCCs(Graph, Roots)
3: for SCC ∈ SCCs do
4: if IsCyclic(SCC) then
5: for d ∈ SCC do
6: S ← Unground(S, d)
7: end for
8: repeat
9: S′ ← S
10: for d ∈ SCC do
11: E ← Evaluate(pre(d), S)
12: P′ ← GroundPredicates(d, E)
13: S ← S ∪ P′
14: end for
15: until S = S′
16: else
17: for d ∈ SCC do
18: S ← Unground(S, d)
19: E ← Evaluate(pre(d), S)
20: P′ ← GroundPredicates(d, E)
21: S ← S ∪ P′
22: end for
23: end if
24: end for
25: return S
26: end procedure
it. In both cases the predicate is added to Nodes. Lines 8–11 apply conjunctive effects recursively, with Derive set to false so that derived predicates are not recomputed after each individual effect. If Derive is true (line 13), the function calls SolveDerived (Algorithm 2) with Nodes as root nodes, so only the derived predicates that depend on the modified predicates are re-evaluated. The function returns the updated state and the set of modified nodes.
Wilcoxon signed-rank comparisons for the SUAVE experiments
This section reports the paired Wilcoxon signed-rank comparisons for experiments 1 and 2 and extended experiments 1 and 2 of the SUAVE exemplar. The test setup and hypotheses are described in § 8.1, and the comparisons for experiment 3 and extended experiment 3 are reported in Table 6, whose caption also explains the layout and color legend of the tables below.
Per-experiment results of the scalability experiments
This section reports planning time and plan length for each scalability experiment of the navigation use case. The experimental design and setup are described in § 8.3, and the results are summarized in Table 8 and Figure 7. In Figure 8 and Figure 11, the no-adaptation curve reports A* search.

Figure 11. S4 results: Planning time and plan length as mission-level actions increase. The shaded area shows the standard deviation. EG stands for the eager greedy search.
Algorithm 3 Apply Action Effects and Selectively Re-evaluate Derived Predicates
1: procedure ApplyEffects(S, Eff, Graph, Nodes, Derive)
2: if Eff = (p o₁ … oₙ) then
3: S ← S ∪ {Eff}
4: Nodes ← Nodes ∪ {Eff}
5: else if Eff = (not (Eff′)) then
6: S ← S \ {Eff′}
7: Nodes ← Nodes ∪ {Eff′}
8: else if Eff = (and (Eff′₁ … Eff′ₖ)) then
9: for e ∈ {Eff′₁, …, Eff′ₖ} do
10: S, Nodes ← ApplyEffects(S, e, Graph, Nodes, false)
11: end for
12: end if
13: if Derive then
14: S ← SolveDerived(Graph, Nodes, S)
15: end if
16: return S, Nodes
17: end procedure
Figure 8. S1 results: Planning time and plan length as map size increases. The shaded area shows the standard deviation. EG stands for the eager greedy search.
Figure 9. S2 results: Planning time and plan length as architectural configurations increase. The shaded area shows the standard deviation. EG stands for the eager greedy search.

Figure 9. (a) Planning time as architectural configurations increase. (b) Plan length as architectural configurations increase. Both search strategies overlap.

Figure 10. S3 results: Planning time and plan length as corridor types increase. The shaded area shows the standard deviation. EG stands for the eager greedy search.
References
- [1]Esther Aguado, Virgilio Gomez, Miguel Hernando, Claudio Rossi, and Ricardo Sanz. 2024. A survey of ontology-enabled processes for dependable robot autonomy. Frontiers in Robotics and AI 11 (2024), 1377897.DOI
- [2]Esther Aguado, Zorana Milosevic, Carlos Hernández, Ricardo Sanz, Mario Garzon, Darko Bozhinoski, and Claudio Rossi. 2021. Functional self-awareness and metacontrol for underwater robot autonomy. Sensors 21, 4 (2021), 1210.DOI
- [3]Elvin Alberts, Ilias Gerostathopoulos, Ivano Malavolta, Carlos Hernández Corbato, and Patricia Lago. 2025. Software architecture-based self-adaptation in robotics. Journal of Systems and Software 219 (2025), 112258. doi:10.1016/j.jss.2024.112258DOI
- [4]Franz Baader, Ian Horrocks, Carsten Lutz, and Ulrike Sattler. 2017. An Introduction to Description Logic. Cambridge University Press.DOI
- [5]Stephen Balakirsky, Zeid Kootbally, Thomas R. Kramer, Anthony Pietromartire, Craig Schlenoff, and Satyandra K. Gupta. 2013. Knowledge driven robotics for kitting applications. Robotics Auton. Syst. 61, 11 (2013), 1205–1214. doi:10.1016/J.ROBOT.2013.04.006DOI
- [6]Stefano Borgo, Amedeo Cesta, Andrea Orlandini, and Alessandro Umbrico. 2019. Knowledge-based adaptive agents for manufacturing domains. Eng. Comput. 35, 3 (2019), 755–779. doi:10.1007/S00366-018-0630-6
- [7]Stefan Borgwardt, Jörg Hoffmann, Alisa Kovtunova, Markus Krötzsch, Bernhard Nebel, and Marcel Steinmetz. 2022. Expressivity of Planning with Horn Description Logic Ontologies. In Thirty-Sixth AAAI Conference on Artificial Intelligence (AAAI 2022). AAAI Press, 5503–5511. doi:10.1609/AAAI.V36I5.20489DOI
- [8]Stefan Borgwardt, Jörg Hoffmann, Alisa Kovtunova, and Marcel Steinmetz. 2021. Making DL-Lite Planning Practical. In Proceedings of the 18th International Conference on Principles of Knowledge Representation and Reasoning (KR 2021). 641–645. doi:10.24963/KR.2021/61DOI
- [9]Darko Bozhinoski, Mario Garzon Oviedo, Nadia Hammoudeh Garcia, Harshavardhan Deshpande, Gijs van der Hoorn, Jon Tjengrer, Andrzej Wasowski, and Carlos Hernandez Corbato. 2022. MROS: runtime adaptation for robot control architectures. Advanced Robotics 36, 11 (2022), 502–518. doi:10.1080/01691864.2022.2039761DOI
- [10]Darko Bozhinoski and Jasper Wijkhuizen. 2021. Context-based navigation for ground mobile robot in semi-structured indoor environment. In 2021 Fifth IEEE International Conference on Robotic Computing (IRC). 82–86. doi:10.1109/IRC52167.2021.00019arxiv.org/abs/2111.12111
- [11]Victor Braam, Nicolas D’Ippolito, Jeff Kramer, Daniel Sykes, and Sebastian Uchitel. 2017. An Extended Description of MORPH: A Reference Architecture for Configuration and Behaviour Self-Adaptation. In Software Engineering for Self-Adaptive Systems III. Assurances (Lecture Notes in Computer Science), Rogério de Lemos, David Garlan, Carlo Ghezzi, and Holger Giese (Eds.). Springer International Publishing, Cham, 377–408. doi:10.1007/978-3-319-74183-3_13
- [12]Diego Calvanese, Marco Montali, Fabio Patrizi, and Michele Stawowy. 2016. Plan Synthesis for Knowledge and Action Bases. In Proceedings of the Twenty-Fifth International Joint Conference on Artificial Intelligence (IJCAI 2016). IJCAI/AAAI Press, 1022–1029. http://www.ijcai.org/Abstract/16/149
- [13]Javier Câmara, Bradley Schmerl, and David Garlan. 2020. Software Architecture and Task Plan Co-Adaptation for Mobile Service Robots. In Proceedings of the IEEE/ACM 15th International Symposium on Software Engineering for Adaptive and Self-Managing Systems (SEAMS ’20). ACM Press, New York, NY, USA, 125–136. doi:10.1145/3387939.3391591DOI
- [14]Carlos Hernández Corbato. 2013. Model-Based Self-Awareness Patterns for Autonomy. Ph. D. Dissertation. Universidad Politécnica de Madrid.
- [15]N. Correll, K. E. Bekris, D. Berenson, O. Brock, A. Causo, K. Hauser, K. Okada, A. Rodriguez, J. M. Romano, and P. R. Wurman. 2017. Analysis and Observations From the First Amazon Picking Challenge. IEEE Transactions on Automation Science and Engineering PP, 99 (2017), 1–17. doi:10.1109/TASE.2016.2600527DOI
- [16]Stefan Edelkamp and Jörg Hoffmann. 2004. PDDL2. 2: The language for the classical part of the 4th international planning competition. Technical Report. Technical Report 195, University of Freiburg.
- [17]Maria Fox and Derek Long. 2003. PDDL2.1: An extension to PDDL for expressing temporal planning domains. Journal of artificial intelligence research 20 (2003), 61–124.DOI
- [18]Luca Gherardi and Nico Hochgeschwender. 2015. RRA: Models and tools for robotics run-time adaptation. In 2015 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS). 1777–1784. doi:10.1109/IROS.2015.7353608DOI
- [19]Robert P. Goldman and Peter Kettler. 2012. “Type Problem in Domain Description”, or ‘Outsiders’ Suggestions for PDDL Improvement. In Proceedings of the 3rd Workshop on the International Planning Competition (WS-IPC 2012), ICAPS 2012. Atibaia, Brazil, 43. https://icaps12.icaps-conference.org/workshops/ipc2012-proceedings.pdf#page=47
- [20]Babak Bagheri Hariri, Diego Calvanese, Marco Montali, Giuseppe De Giacomo, Riccardo De Masellis, and Paolo Felli. 2013. Description Logic Knowledge and Action Bases. J. Artif. Intell. Res. 46 (2013), 651–686. doi:10.1613/JAIR.3826DOI
- [21]Malte Helmert. 2006. The fast downward planning system. Journal of Artificial Intelligence Research 26 (2006), 191–246.
- [22]Carlos Hernández, Julita Bermejo-Alonso, and Ricardo Sanz. 2018. A Self-Adaptation Framework Based on Functional Knowledge for Augmented Autonomy in Robots. Integrated Computer-Aided Engineering 25, 2 (2018), 157–172.DOI
- [23]Nico Hochgeschwender, Sven Schneider, Holger Voos, Herman Bruyninckx, and Gerhard K. Kraetzschmar. 2016. Graph-based software knowledge: Storage and semantic querying of domain models for run-time adaptation. In Proc. Intl. Conf. on Simulation, Modeling, and Programming for Autonomous Robots (SIMPAR 2016). IEEE, 83–90. doi:10.1109/SIMPAR.2016.7862379DOI
- [24]Ian Horrocks, Peter F. Patel-Schneider, Harold Boley, Said Tabet, Benjamin Grosof, and Mike Dean. 2004. SWRL: A Semantic Web Rule Language Combining OWL and RuleML. W3C Member submission 21, 79 (2004), 1–31.
- [25]2022. IEEE Standard for Autonomous Robotics (AuR) Ontology. IEEE Std 1872.2-2021 (2022), 1–49. doi:10.1109/IEEESTD.2022.9774339
- [26]Tobias John and Patrick Koopmann. 2024. Planning with OWL-DL Ontologies. In 27th European Conference on Artificial Intelligence (ECAI 2024) (Frontiers in Artificial Intelligence and Applications, Vol. 392). IOS Press, 4165–4172. doi:10.3233/FAIA240988DOI
- [27]Erez Karpas and Daniele Magazzeni. 2020. Automated planning for robotics. Annual Review of Control, Robotics, and Autonomous Systems 3, 1 (2020), 417–439.DOI
- [28]Krotkov, Eric, Hackett, Douglas, Jackel, Larry, Perchsbacker, Michael, Pippine, James, Strauss, Jesse, Pratt, Gill, Orlowski, and Christopher. 2018. The DARPA Robotics Challenge Finals: Results and Perspectives. Springer International Publishing, Cham, 1–26. doi:10.1007/978-3-319-74666-1_1DOI
- [29]Alex Lotz, Juan F. Inglés-Romero, Cristina Vicente-Chicote, and Christian Schlegel. 2013. Managing Run-Time Variability in Robotics Software by Modeling Functional and Non-functional Behavior. In Enterprise, Business-Process and Information Systems Modeling, Selmin Nurcan, Henderik A. Proper, Pnina Soffer, John Krogstie, Rainer Schmidt, Terry Halpin, and Ilia Bider (Eds.). Springer Berlin Heidelberg, Berlin, Heidelberg, 441–455.DOI
- [30]Francisco Martín, Jonatan Ginés, Francisco J. Rodríguez, and Vicente Matellán. 2021. PlanSys2: A Planning System Framework for ROS2. In IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS 2021). IEEE.arxiv.org/abs/2107.00376
- [31]Francisco Martín Rico, Matteo Morelli, Huascar Espinoza, Francisco J. Rodríguez-Lera, and Vicente Matellán Olivera. 2021. Optimized Execution of PDDL Plans using Behavior Trees. In Proceedings of the 20th International Conference on Autonomous Agents and MultiAgent Systems (Virtual Event, United Kingdom) (AAMAS ’21). International Foundation for Autonomous Agents and Multiagent Systems, Richland, SC, 1596–1598.
- [32]Andrea Micheli, Arthur Bit-Monnot, Gabriele Röger, Enrico Scala, Alessandro Valentini, Luca Framba, Alberto Rovetta, Alessandro Trappaso, Luigi Bonassi, Alfonso Emilio Gerevini, Luca Iocchi, Felix Ingrand, Uwe Köckemann, Fabio Patrizi, Alessandro Saetti, Ivan Serina, and Sebastian Stock. 2025. Unified Planning: Modeling, manipulating and solving AI planning problems in Python. SoftwareX 29 (2025), 102012. doi:10.1016/j.softx.2024.102012DOI
- [33]Stefan Niemczyk and Kurt Geihs. 2015. Adaptive Run-Time Models for Groups of Autonomous Robots. In 2015 IEEE/ACM 10th International Symposium on Software Engineering for Adaptive and Self-Managing Systems. 127–133. doi:10.1109/SEAMS.2015.21DOI
- [34]Stefan Niemczyk, Stephan Opfer, Nugroho Freivanius, and Kurt Geihs. 2017. ICE: self-configuration of information processing in heterogeneous agent teams. In Proceedings of the Symposium on Applied Computing (Marrakech, Morocco) (SAC ’17). Association for Computing Machinery, New York, NY, USA, 417–423. doi:10.1145/3019612.3019653DOI
- [35]Arne Nordmann, Ralphan Lange, and Francisco Martín Rico. 2021. System modes - digestible system (re-)configuration for robotics. In 2021 IEEE/ACM 3rd Intl. Workshop on Robotics Software Engineering (RoSE). IEEE, 19–24. doi:10.1109/RoSE52553.2021.00010DOI
- [36]Yu-Sik Park, Hyung-Min Koo, and In-Young Koo. 2012. A task-based and resource-aware approach to dynamically generate optimal software architecture for intelligent service robots. Software: Practice and Experience 42, 5 (2012), 519–541.DOI
- [37]Gustavo Rezende Silva. 2026. kas-lab/navigation_planta: Version 1.1.0 - TAAS submission October 2026. doi:10.5281/zenodo.23647225DOI
- [38]Gustavo Rezende Silva. 2026. kas-lab/suave_planta: Version 1.2.0 - TAAS submission October 2026. doi:10.5281/zenodo.23619542DOI
- [39]Gustavo Rezende Silva, Juliane Päßler, Jeroen Zwanepol, Elvin Alberts, S I zeth Tapia Tarifa, Ilias Gerostathopoulos, Einar Broch Johnsen, and Carlos Hernández Corbato. 2023. SUAVE: An Exemplar for Self-Adaptive Underwater Vehicles. In Proc. 18th IEEE/ACM Symposium on Software Engineering for Adaptive and Self-Managing Systems (SEAMS 2023). IEEE, 181–187.arxiv.org/abs/2303.09220
- [40]Gustavo Rezende Silva, Juliane Päßler, S. Lizeth Tapia Tarifa, Einar Broch Johnsen, and Carlos Hernández Corbato. 2025. ROSA: a knowledge-based solution for robot self-adaptation. Frontiers in Robotics and AI Volume 12 - 2025 (2025). doi:10.3389/frobt.2025.1531743DOI
- [41]SEBoK Editorial Board. 2023. The Guide to the Systems Engineering Body of Knowledge (SEBoK), v. 2.8. https://www.sebokwiki.org
- [42]Robert Tarjan. 1972. Depth-First Search and Linear Graph Algorithms. SIAM J. Comput. 1, 2 (1972), 146–160. doi:10.1137/0201010 arXiv:https://doi.org/10.1137/0201010
- [43]Sylvie Thiébaux, Jörg Hoffmann, and Bernhard Nebel. 2005. In defense of PDDL axioms. Artificial Intelligence 168, 1 (2005), 38–69. doi:10.1016/j.artint.2005.05.004DOI
- [44]Robert Valner, Veiko Vunder, Alvo Aabloo, Mitch Pryor, and Karl Kruusamäe. 2022. TeMoto: A Software Framework for Adaptive and Dependable Robotic Autonomy With Dynamic Resource Management. IEEE Access 10 (2022), 51889–51907.DOI
- [45]Safdar Zaman, Farhan Ahmad, Mohammad Qasim Khan, Shabir Ali Shah, Asma Jabeen, and Nouman Aftab. 2019. Fault Detection Using Sensors Data Trends for Autonomous Robotic Mapping. In 2019 International Conference on Engineering and Emerging Technologies (ICEET). IEEE, 1–6.DOI
- [46]Safdar Zaman, Gerald Steinbauer, Johannes Maurer, Peter Lepej, and Suzana Uran. 2013. An integrated model-based diagnosis and repair architecture for ROS-based robot systems. In 2013 IEEE International Conference on Robotics and Automation. 482–489. doi:10.1109/ICRA.2013.6630618DOI

