The deployment of complex autonomous systems into open environment calls for robust, modular and verifiable software architectures. Skillset models, which encapsulate the capabilities of the autonomous robots into modular Skills, have emerged to address these challenges. Expressed within an intermediary layer of the robot's architecture, Skillsets break down high level actions produced by the Deliberative layer into lower level actions, executed by functional components. The use of a Domain Specific Language (DSL) for Skillset modeling allow formal methods to provide robust code generation and model verification. However, as Skill-based architectures are more and more developed, the true benefits of opting for such an approach have yet to be investigated.
The development of autonomous systems presents the major challenge of integrating low-level functions
(e.g., actuation) and high-level decision-making capabilities (e.g., task scheduling) into robust and reliable
software architectures [
The Robot Language DSL has been evolving over the past few years, improving both on the aspects
of robustness and verifiability [
CEUR
ceur-ws.org
level in the three-layer architectures used in autonomous systems by proposing new approaches to
specify Skill-level and multi-level recovery strategies, with a focus on a Skill-based Executive layer as
defined by Albore et al.[
As a first step, we present an early-stage analysis of recent Skill-based architectures making use of the ONERA Robot Skill Toolchain1 with a focus on identifying best practices, common pitfalls, and ofering guidelines for future developments. To this end, we focus on three research questions (RQs): RQ 1. To which extent is the level of abstraction proposed by the Skills suitable for diferent applications? Metrics: Assessment of the Reusability and adaptivity of Skills both across missions and across systems.
RQ 2. In what ways does the abstraction level of Skills influence the management of system complexity? Metrics: Assessment of the Mission-level complexity and architecture-level complexity
RQ 3. Does the use of Skills facilitate the integration of error detection and handling mechanisms? Metrics: Nature and localization of the error handling mechanisms in the Skill-based architecture.
With these three research questions set, we present the sources and methods used for the experiment in Section 2. Section 3 then summarizes our observations and results before concluding with Section 4.
First, lets us point out that the studied Skill-based approach is an open-source research project, with a limited community of developers. Nevertheless, over the past few years, numerous works using this technology have been conducted. Discarding versions form before 2022, the 22 most recent projects involving a Skill-based architecture have been investigated in the present work. Data ranging from interpretations of the code to interviews with the developers has been collected. These projects were conduced by several French laboratories, namely ONERA and LAAS-CNRS in Toulouse as well as the LIRMM in Montpellier. The data is diverse, as are involved a wide variety of robot types: Manipulator Arms, Unmanned Aerial Vehicles (UAVs), Unmanned Marine Vehicles (UMVs), Unmanned Ground Vehicles (UGVs) and Legged Robots, sometimes working all together to achieve the same goal. Each project is treated as an individual case study and each Skill-based architecture is assessed, following the research questions, on how the Skills were designed, reused and adapted. Thirteen individuals (including Ph.D. students and senior researchers) involved in these projects were interviewed. In addition to code analysis, semi-structured interviews were conducted to elucidate the mission contexts, rationale behind design decisions, and practical challenges faced during the implementation of the Skills. The interview protocol was meticulously designed to address the three primary research questions. 1Robot Skills documentation Developers provided valuable insights into the process of implementing Skill-based architectures, specifically focusing on strategies for managing system complexity, Skill correctness, and integrating error-handling mechanisms.
First, we investigated the reusability and genericity of Skills. The analysis of the 22 project codes shows that while Skills are theoretically meant to be reusable and platform-independent, they tend to only be reused within the same robot type (e.g., UAVs, UGVs). Generic Skillset models have been developed for each type and the crossing of a Skill model between diferent robot types is rare. This is mainly due to diverging functional needs. For example, while UGVs and UAVs may share the same capability of reaching a specific waypoint, UAVs need to process additionnal information such as altitude values, lfight status or safety requirements. Therefore, distinct movement-related Skills have been implemented. This observation leads to the matter of adaptivity of the Skills. Due to the lack of modularity and specific project needs, developer teams adopted diverging solutions. Some directly modified generic Skillsets to fit mission-specific needs, while others created new, dedicated Skillsets for a precise robot type. We observe an unbalance between genericity and adaptivity of Skill models: On the one hand, the more a Skill is generic, the more dificult it is to implement for specific needs. On the other hand, highly adaptive Skillsets are bound to their initial robot type and cannot easily be adapted elsewhere. The framework does not currently propose explicit, documented solutions on the matter. However, we observe significant similarities between the existing models and argue that the creation of a truly generic Skillset model is possible. To this end, an unified framework for designing Skill-based architectures is needed.
The key takeaways regarding RQ 1 are: - The framework does not currently propose an explicit and documented list of generic Skills. - The framework does not include a built-in extension mechanism (such as inheritance in objectoriented programming) to ease the redefinition and specialization of Skillsets.
- There is currently no training material on generic Skill reuse.
Complexity management can be tackled in many ways. First insights from the interviewed participants concerned mission complexity. In this context, the Skill abstraction helps simplify interactions with non-experts and stakeholders by focusing on what the robot does rather than how it operates at a low level. This approach was particularly useful in projects with non-technical stakeholders, such as marine biologists in one of the case studies.
Another perspective is at the architecture level, where Skills may also play a role for managing complexity. According to the interviewed participants, without a Skill-based architecture, the development process would be longer and significantly more complex. Indeed, the abstraction of the robot’s capabilities into Skills prevents the developers from making direct connections between high level tasks and low-level functional components: The Deliberative layer only reasons in term of Skill activation while the Skills manage the execution of the lower-level components. This modular approach also simplifies the integration of new functionalities. The use of ROS2 as the middleware distributing the Skill-based architecture may also influence the architecture-level complexity. The Executive layer uses ROS2 to harvest and propagate useful information to the whole system. Furthermore, robots from diferent projects (e.g., Boston Dynamics®Spot and Kinova®manipulator) were able to communicate and coordinate Skills efectively thanks to the shared middleware.
Key takeways regarding RQ 2 are: - The abstraction of the robot’s capabilities allows for simpler and clearer mission definitions. - The abstracted Skills simplify the implementation and/or modification of the architecture by allowing for clear connections between modular components. - Thanks to the ROS2 middleware, the Skillset Manager is able to centralize and spread information internally as well as externally, in multi-agent scenarios.
The Skillset manager is C++ code generated from a Skillset model which has been formally verified
beforehand [
Key takeways regarding RQ 3 are: - There is a lack of method to bind fault propagation analysis to Skill models - There is a need for documented good practices to help developers choose the nature and location of the error detection and recovery mechanisms - There is a need for tools to identify scenarios in which multiple (possibly incompatible) recovery actions are simultaneously triggered.
The present study has demonstrated, through an examination of 22 projects, the benefits and challenges inherent to the use of Skill-based architectures. Our findings indicate that, while Skills ofer a robust mechanism for modular programming and rapid reconfiguration, they have yet to meet all their promises. Indeed, due to a lack of genericity and adaptivity, such implementations are currently not fully accessible to non-experts, because applications to specific robotic types, with specific functional needs, necessitate a process of careful consideration and adaptation. Regarding the genericity and adaptability of Skills, we posit that the development of truly generic Skill models is feasible. While this endeavor is beyond the scope of the current Ph.D. research, future studies should be conducted in this direction.
This study has highlighted a clear benefit of implementing Skill-based architectures into increasingly complex autonomous systems: A list of benefits in term of mission-level and architecture-level complexity management has transpired from the interviews while no significant downsides have been observed. On top of the the previously mentioned aspects, complexity management can therefore be a reason why developers choose to use Skills.
Our study also underscores the need of a clearly defined framework for the development of both the Skillset models and the Skillset implementations. The absence of formal guidelines allows for significant lfexibility in the approach taken by the developer. This may result in inconsistencies within the implementations and could eventually compromise the safety and robustness of the system. The same lack of precise guidelines applies for the implementation of error detection and handling mechanisms.
In this context, the Future works related to the Ph.D. will be focusing on Skill-level error handling as
well as a multi-level recovery framework with the aim of addressing the need for guidelines to safer,
more robust implementations. To this end, we currently investigate the capabilities of BDI agents in term
of failure handling [