Numerous approaches have been proposed for programming and designing autonomous robot architectures (Kortenkamp et al., 2016). In recent years, two main trends have emerged: component-based frameworks and middlewares–among which ROS (Macenski et al., 2022) stands out due to its widespread adoption in academia and industry–and layered architectures (Barnett et al., 2022). Barnett et al. (2022) reviewed 21 robotics architectures and concluded that most architectures follow a layered pattern, and even those that do not can still have their elements mapped onto a layered architectural structure. Furthermore, they found that all architectures include a bottom functional layer responsible for interacting with the robot’s hardware, an upper task decision layer–whose responsibilities vary across architectures–and an arbitrary number of intermediate layers. This work aims to design a reusable solution for TACA that can be integrated into robotics architectures adhering to these architectural patterns. To achieve this, the proposed solution establishes a clear separation between architectural management and task logic, organizing them into distinct layers, or subsystems, as commonly referred to in the self-adaptive systems community.

The LAAS architecture (Alami et al., 1998) is an example of a three-layered architecture consisting of a functional layer, an executive, and a decision layer. The functional layer contains the robot’s control and perception algorithms. The executive layer receives a task plan from the decision layer and selects functions from the functional layer to realize each action in the task plan. The decision layer includes a planner that generates task plans and a supervisor responsible for monitoring plan execution and triggering replanning when necessary. More recent examples of layered robot architectures include AEROSTACK (Sanchez-Lopez et al., 2016), designed for aerial drone swarms, and SERA (Garcia et al., 2018), which is tailored for decentralized and collaborative robots. These architectures build on the layered model but focus on providing domain-specific solutions.

Cognitive architectures (Kotseruba and Tsotsos, 2018), such as CRAM (Beetz et al., 2010; Kazhoyan et al., 2021), focus on generating intelligent and flexible behavior by integrating cognitive capabilities such as planning, perception, or reasoning. However, being integral solutions, these works provide a blueprint for the complete robot control system and are not intended for reuse and integration with other methods, thus making it difficult to adapt and customize for specific applications.

Despite advances in self-adaptive robotic systems, fully addressing task and architectural co-adaptation (TACA) with reusable and scalable solutions remains an open challenge (see Table 1). While some studies explore the relationship between task execution and architectural adaptation, only a few explicitly address TACA—and those that do face limitations in reusability and practical applicability in robotics. This work aims to bridge this gap by introducing a knowledge-based framework that can capture the necessary knowledge to solve TACA across different use cases, can be directly applied to robotic systems, and supports modular modifications for incorporating different adaptation strategies.

Alberts et al. (2025) recently conducted a systematic mapping study ² on “robotics software architecture-based self-adaptive systems” (RSASSs), identifying 37 primary studies on RSASSs published since 2011. Among these, Alberts et al. (2025) identified that four studies (Park et al., 2012; Lotz et al., 2013; Gherardi and Hochgeschwender, 2015; Cámara et al., 2020) consider, to varying degrees, the relationship between the tasks a robot performs and architectural adaptation. A non-systematic snowballing of the primary studies identified by Alberts et al. (2025) revealed two additional studies (Braberman et al., 2017; Valner et al., 2022) that also explore this relationship.

In the context of knowledge-based methods, Alberts et al. (2025) identified six studies (Park et al., 2012; Niemczyk and Geihs, 2015; Hochgeschwender et al., 2016; Niemczyk et al., 2017; Bozhinoski and Wijkhuizen, 2021; Silva et al., 2023) that use knowledge representation techniques to capture knowledge required for the adaptation logic. Among these (Bozhinoski and Wijkhuizen, 2021; Silva et al., 2023), do not propose solutions for RSASSs but instead demonstrate the application of Metacontrol (Hernández et al., 2018; Bozhinoski et al., 2022) in different robotics use cases. While these methods do not address TACA, they provide valuable insights for designing knowledge-based approaches to self-adaptation.

Park et al. (2012) introduced the SHAGE framework for task-based and resource-aware architecture adaptation in robotic systems. SHAGE partially solves TACA, as it can adapt the robot’s architecture at runtime to specifically realize each action in its task plan when it needs to be performed. However, SHAGE does not support task execution adaptation based on the robot’s architectural state. SHAGE promotes reusability by leveraging architectural models and knowledge captured with an ontology to reason about adaptation at runtime. However, to the best of our knowledge, there is no implementation of the SHAGE framework that works with common robotic frameworks. Thus, it is not possible to directly reuse SHAGE.

Lotz et al. (2013) proposed a method to model operational and quality variability using two distinct (DSLs) models. Their work provides a high-level discussion on how these models could be used at runtime to enable architectural adaptation based on the actions executed by the robot. An interesting aspect of their approach is the clear separation between functional and non-functional requirements: one model captures the task deliberation logic, functional requirements, and their variation points, while the other focuses on non-functional requirements and their possible variations. While this separation of concerns simplifies the modeling process, combining task deliberation with functional requirements reduces reusability. Any change in the task deliberation logic directly impacts the modeling of functional requirements, making the approach less flexible. Additionally, they do not provide sufficient details on how these models are used at runtime, nor do they present an evaluation to demonstrate the feasibility of their approach.

Gherardi and Hochgeschwender (2015) proposed RRA as a model-based approach for structural, parameter, and connection adaptation in robotic systems. Their method employs six distinct models to capture all the knowledge required for adaptation. These models represent the robot’s architecture and its variability, its functionalities and their variability, the mapping between functions and architecture, the required interfaces (i.e., inputs, outputs, and data types) for the adaptation logic, and the adaptation logic itself. RRA models the dependencies between the tasks a robot can perform and the architectural configurations needed to accomplish them. This is achieved by decomposing each task into multiple functionalities and capturing the available architectural variants for realizing each function. At deployment time, the robot’s operator selects a task, and RRA manages only the functionalities required for that task. Although RRA considers the relationship between tasks and architecture to some extent, it cannot be classified as TACA, as this dependence is only accounted for at deployment time. Architectural adaptation occurs based on the selected task rather than dynamically at runtime in response to the individual actions the robot needs to perform. Moreover, RRA does not adapt the task execution based on the robot’s architectural state.

Valner et al. (2022) proposed the TeMoto as a general solution for robotic systems’ dynamic task and resource management. TeMoto partially solves TACA, as it can adapt the robot’s architecture to realize the actions being performed by the robot. TeMoto does not completely fulfill TACA as it cannot adapt the task execution given the robot’s architectural state. TeMoto provides reusable mechanisms for resource management, but reusability is limited since the adaptation logic must be implemented for all managed resources, and the knowledge about the dependencies between actions and architecture are programmatically included in the actions’ code.

Braberman et al. (2017) proposed MORPH as a reference architecture to enable TACA. They showcased on a conceptual level how MORPH can be applied to enable TACA in an unmanned aerial vehicle (UAV) use case. However, since MORPH is only demonstrated at a conceptual level, it is hard to evaluate the feasibility of applying MORPH to robotic systems at runtime. To the best of our knowledge, there is no framework implementing the complete MORPH architecture. Therefore, it is not possible to directly reuse MORPH.

In the context of TACA, Cámara et al. (2020) developed a method for finding optimal task and reconfiguration plans for an autonomous ground vehicle (AGV) navigating in a graph-like environment. To enable optimal planning within reasonable time limits, their method first reduces the search space by finding all possible reconfiguration plans and then computing the shortest N paths the robot can take to reach its goal. Then, it uses this information along with task-specific models that capture mission quality attributes (e.g., energy consumption, collision probabilities) and a preferred utility to apply model checking and determine an optimal reconfiguration plan for each path. Finally, an optimization function selects the best plan based on a predefined utility function (e.g., minimizing energy consumption, time, or collision probability). Although their approach reduces the planning search space to improve planning time, their experiments show that solving the navigation use case still takes an average of 15.1 s, an impractical duration for robots that frequently need to replan at runtime to handle uncertainties. Additionally, while the approach is model-based, it relies on task-specific model transformations (e.g., converting the map or battery model into PRISM model snippets), which require dedicated implementations for different tasks. This limits the reusability of their approach for different types of tasks, as it requires a considerable amount of development effort.

Hochgeschwender et al. (2016) argue that robots should have access to and exploit software-related knowledge about how they were engineered to support runtime adaptation. They demonstrate how labeled property graphs (LPGs) can be used to persistently store and compose different domain models specified with (DSL) to enable runtime architectural adaptation. Although their approach is interesting, its reusability is limited as it does not define a knowledge model that can be reused for other applications: for each different use case and DSL the roboticist is responsible for creating a translation from the DSL to the corresponding LPG.

Niemczyk and Geihs (2015); Niemczyk et al. (2017) propose ICE as a method for adapting the information processing subsystem in multi-robot systems, specifically by adapting the connections between system components. Their approach uses an ontology to define each component’s required inputs and outputs, along with quality-of-service information for each connection. This ontology is then translated into answer set programming (ASP), and an ASP solver determines an optimal configuration. While they conceptually demonstrate how their method could be applied to robots, they do not demonstrate it with a robotic system. Moreover, their approach focuses solely on structural and connection adaptation to maintain the functionality of the information processing subsystem, without considering other subsystems of the robotic system.

Hernández et al. (2018); Bozhinoski et al. (2022) proposed Metacontrol as a knowledge-based solution for parameter and structural adaptation. Metacontrol leverages the TOMASys (Hernández et al., 2018) ontology to capture the knowledge required for the adaptation logic and to reason at runtime to decide when and how the system should adapt. Similar to RRA, Metacontrol decomposes the system into functionalities, using TOMASys to represent the robot’s functionalities, the architectural variants that implement each functionality, and the non-functional requirements associated with these variants. However, Metacontrol cannot perform TACA as TOMASys does not capture the relationship between the system functionalities and the robot’s actions.

In conclusion, existing works that fully address TACA (Braberman et al., 2017; Cámara et al., 2020) face limitations in reusability and practical applicability in robotics. The authors of MORPH (Braberman et al., 2017) note that no complete system has been developed, and they have not demonstrated its feasibility. While the approach proposed by Cámara et al. (2020) provides the most complete solution to TACA in the literature, it also faces reusability limitations by relying on multiple distinct (DSL) models and requiring task-specific implementations for model transformations. To address these limitations, this work proposes capturing all the knowledge required for adaptation logic in a single knowledge model. This approach requires only one model–conforming to the proposed knowledge model–to be designed for each application. Additionally, an open-source reference implementation of ROSA is provided, enabling researchers to reuse, extend, and build upon the proposed solution.

On the other hand, previous knowledge-based methods for RSASS (Park et al., 2012; Niemczyk and Geihs, 2015; Niemczyk et al., 2017; Hochgeschwender et al., 2016; Hernández et al., 2018; Bozhinoski et al., 2022) do not capture all knowledge required to enable TACA. They either lack the ability to capture the relationship between the robot’s actions and architecture (Hochgeschwender et al., 2016; Hernández et al., 2018; Bozhinoski et al., 2022), or the knowledge required to decide when and how the robotic system should adapt (Park et al., 2012). Although these works do not capture all the knowledge required for TACA, they are able to capture, to varying degrees, knowledge that supports RSASSs. Thus, this work takes inspiration from them to design ROSA’s knowledge model while addressing their limitations. More concretely, ROSA’s knowledge model is designed to capture the relationship between the robot’s actions and architecture and the knowledge required to decide when and how TACA should be performed.

This work assumes that the robotics architecture is layered, containing a bottom functional layer, an upper task decision layer, and an arbitrary number of layers in between, as common in robotics architectures (Barnett et al., 2022). The functional layer is responsible for interacting with the robots’ sensors and actuators, and the task decision layer is responsible for task planning and execution ³ . To enable TACA with ROSA, the task decision layer shall use the knowledge contained in R O S A ’s KB to decide which actions to perform, and it must update the KB with the actions selected to be performed to enable ROSA to configure the robot’s architecture accordingly. To enable architectural adaptation, the robotic architecture must be component-based, its components must be able to be activated and deactivated at runtime, and its components’ parameters must be able to be adapted at runtime.

R O S A ’s architecture adheres to the MAPE-K loop (Kephart and Chess, 2003). It monitors the managed subsystem, analyzes whether adaptation is required, when needed, plans how the managed subsystem should be reconfigured, and executes the selected reconfigurations. All these steps interact with a central KB.

To promote reusability, composability, and extensibility, the architecture is designed with the following premises: (1) all knowledge required for the adaptation logic is captured in the central KB, (2) there is no inter-component communication between the MAPE components (Weyns et al., 2013), (3) the MAPE components insert and read data from or to the KB via standardized interfaces, and (4) there is no explicit coordination between the MAPE-K components. Premise 1 promotes reusability by only requiring the modeling of the relevant knowledge for applying ROSA to different applications in a single model. Premises 1 to 4 promote composability and extensibility by allowing the MAPE components to be stateless and self-contained.

To enable adaptation, the knowledge model captures what can be adapted with the architectural knowledge depicted in Figure 2a; why to adapt and how to select an adaptation with the adaptation heuristics knowledge depicted in Figure 2b; and how to execute an adaptation with the reconfiguration plan knowledge depicted in Figure 2c. Tables 2–4 define each element in the model alongside examples based on SUAVE to ease its understanding.

To enable ROSA to reason about when the managed subsystem should be adapted and what type of adaptation is needed, the KB contains a set of generic rules that define how the status of the system can be inferred based on monitored information, e.g., how to infer if a constraint is violated and how to propagate a constraint violation. A change in status only occurs when measurements are updated or when a component fails. The complete status inference rules are depicted as decision diagrams in Figure 3.

The status of the required Components, Functions, and Actions indicate when and what type of adaptation is needed. When a Component is “unsolved” or in “configuration error” (see Figure 3c), parameter adaptation is required, i.e., a new component configuration needs to be selected. When a required Function is “unsolved” or in “configuration error” (see Figure 3e), structural adaptation is required, i.e., a new function design needs to be selected. When a required Action is “unfeasible” (see Figure 3f), TACA is needed, i.e., the task decision layer must choose a new action to perform, consequently triggering architectural adaptation.

The proposed knowledge model was presented as a conceptual data model (CDM) in a non-machine-readable format. To transform the knowledge model into a machine-readable format while maintaining its semantics and structure, its representation requirements must be identified and used to select a suitable technology to implement it. The representation requirements imposed by the proposed knowledge model are:

1. n-ary relationships: the knowledge model contains relationships with different arity ⁴ , e.g., the constraint relationship has arity 5, and the measurement relationship has arity 1;

These requirements limit which technology can be used. For example, technologies using graph-based or descriptive logic-based knowledge representation techniques (e.g., OWL (Antoniou and van Harmelen, 2004)) do not satisfy the representation requirements above apart from allowing attributes for entities (part of Requirement 4). Although it is possible to transform the proposed knowledge model into one that can be represented with graph-based or description logic-based approaches by reifying the model (Olivé, 2007), each reification applied to the original model can be considered as an introduction of a semantic disparity between the CDM and the machine-readable model, making it harder to understand and reuse it. Thus, this work does not consider applying reification.

A technology that satisfies all representation requirements is TypeDB (Dorn and Pribadi, 2023; 2024). TypeDB is a polymorphic database based on type theory that implements the polymorphic entity-relation-attribute (PERA) (Dorn and Pribadi, 2024) data model. The PERA model subsumes the CDM used as the meta-model for the proposed ROSA model, allowing it to be implemented without modifications. Furthermore, TypeDB has a reasoning system that is able to reason over rules of the form antecedent ⇒ consequent to infer new facts at query time. Where antecedent represents a precondition for inferring the consequent and is expressed as a first-order logic expression combining elements from the model (i.e., entities, relationships, and individuals), and the consequent is a single new fact inferred when the antecedent holds true. The ROSA model rules presented in Figure 3 can be implemented with TypeDB without modifications. For these reasons, this work uses TypeDB to implement the proposed knowledge model and rules.

ROSA is implemented as a ROS 2-based system, where the MAPE-K components (depicted in Figure 1) are realized as ROS nodes, and interfaces are implemented using ROS services or topics. The proposed ROSA implementation uses ROS (Robot Operating System) as its robotics framework since ROS is the current de facto standard robotics framework, and it has been designed, among other things, to promote software reusability in the robotics ecosystem (Macenski et al., 2022). In this implementation, ROS handles the communication between system components, schedules callbacks for incoming messages and events, and manages the lifecycle of ROS nodes. The full ROSA implementation is available at https://github.com/kas-lab/rosa ⁶ .