AUML protocols and code generation in the Prometheus design tool

Prometheus is an agent-oriented software engineering methodology. The Prometheus Design Tool (PDT) is a software tool that supports a designer who is using the Prometheus methodology. PDT has recently been extended with two significant new features: support for Agent UML interaction protocols, and code generation

Managing healthcare workflows in a multi-agent system environment

Whilst Multi-Agent System (MAS) architectures appear to offer a more flexible model for designers and developers of complex, collaborative information systems, implementing real-world business processes that can be delegated to autonomous agents is still a relatively difficult task. Although a range of agent tools and toolkits exist, there still remains the need to move the creation of models nearer to code generation, in order that the development path be more rigorous and repeatable. In particular, it is essential that complex organisational process workflows are captured and expressed in a way that MAS can successfully interpret. Using a complex social care system as an exemplar, we describe a technique whereby a business process is captured, expressed, verified and specified in a suitable format for a healthcare MAS.</p

Adding debugging support to the Prometheus methodology

This paper describes a debugger which uses the design artifacts of the Prometheus agent-oriented software engineering methodology to alert the developer testing the system, that a specification has been violated. Detailed information is provided regarding the error which can help the developer in locating its source. Interaction protocols specified during design, are converted to executable Petri net representations. The system can then be monitored at run time to identify situations which do not conform to specified protocols. A process for monitoring aspects of plan selection is also described. The paper then describes the Prometheus Design Tool, developed to support the Prometheus methodology, and presents a vision of an integrated development environment providing full life cycle support for the development of agent systems. The initial part of the paper provides a detailed summary of the Prometheus methodology and the artifacts on which the debugger is based

Prometheus design tool

The Prometheus Design Tool (PDT) supports the structured design of intelligent agent systems. It supports the Prometheus methodology, but can also be used more generally. This paper outlines the tool and some of its many features

Design and Analysis of a Multi-Agent E-Learning System Using Prometheus Design Tool

Agent unified modeling languages (AUML) are agent-oriented approaches that supports the specification, design, visualization and documentation of an agent-based system. This paper presents the use of Prometheus AUML approach for the modeling of a Pre-assessment System of five interactive agents. The Pre-assessment System, as previously reported, is a multi-agent based e-learning system that is developed to support the assessment of prior learning skills in students so as to classify their skills and make recommendation for their learning. This paper discusses the detailed design approach of the system in a step-by-step manner; and domain knowledge abstraction and organization in the system. In addition, the analysis of the data collated and models of prediction for future pre-assessment results are also presented.Comment: 17 figures, 3 table

Agent-oriented software engineering methodologies : analysis and future directions

The Internet of Things (IoT) facilitates in building cyber-physical systems, which are significant for Industry 4.0. Agent-based computing represents effective modeling, programming, and simulation paradigm to develop IoT systems. Agent concepts, techniques, methods, and tools are being used in evolving IoT systems. Over the last years, in particular, there has been an increasing number of agent approaches proposed along with an ever-growing interest in their various implementations. Yet a comprehensive and full-fledged agent approach for developing related projects is still lacking despite the presence of agent-oriented software engineering (AOSE) methodologies. One of the moves towards compensating for this issue is to compile various available methodologies, ones that are comparable to the evolution of the unified modeling language (UML) in the domain of object-oriented analysis and design. These have become de facto standards in software development. In line with this objective, the present research attempts to comprehend the relationship among seven main AOSE methodologies. More specifically, we intend to assess and compare these seven approaches by conducting a feature analysis through examining the advantages and limitations of each competing process, structural analysis, and a case study evaluation method. This effort is made to address the significant characteristics of AOSE approaches. The main objective of this study is to conduct a comprehensive analysis of selected AOSE methodologies and provide a proposal of a draft unified approach that drives strengths (best) of these methodologies towards advancement in this area.publishedVersio

Eclipse-based prometheus design tool

The Prometheus Design Tool (PDT) is a graphical tool that is used to design a Multi-Agent System following the Prometheus Methodology. This paper describes the latest version of PDT which is now integrated into the Eclipse platform, enabling the users to accomplish the full development life-cycle of an agent-oriented application in one IDE and also inherit the rich set of product development features that Eclipse provides. This version of PDT also aims to support simpler integration with tools from other AOSE methodologies where appropriate

A systematic approach for detecting faults in agent designs

This thesis proposes a mechanism, including automated tool support, for early-phase defect detection by comparing the plan structures of a belief-desire-intention (BDI) agent design against the following: (1) requirement models, specified in terms of scenarios and goals; and (2) agent communication models. The intuition of our approach is to extract sets of possible behaviour runs from the agent-behaviour models and to verify whether these runs conform to the specifications of the system-to-be. The proposed approach in this thesis is applicable at design time and does not require source code. Our approach is based on the Prometheus agent-design methodology but is applicable to other methodologies that support the same notions. We evaluate the proposed verification framework on designs, ranging from student projects to case studies of industry-level projects. Our evaluation demonstrates that even a simple specification developed by relatively experienced developers is prone to defects, and our approach is successful in uncovering most of these defects. In addition, we conduct a scalability analysis of our methods, and the outcomes reveal that our approach can scale when designs grow in size

Debugging multi-agent systems with design documents

Debugging multi-agent systems, which are concurrent, distributed, and consist of complex components is difficult, yet crucial. The development of these complex systems is supported by agent-oriented software engineering methodologies which utilise agents as the central design metaphor. The systems that are developed are inherently complex since the components of these systems may interact in flexible and sophisticated ways and traditional debugging techniques are not appropriate. Despite this, very little effort has been applied to developing appropriate debugging tools and techniques. Debugging multi-agent systems without good debugging tools is highly impractical and without suitable debugging support developing and maintaining multi-agent systems will be more difficult than it need be. In this thesis we propose that the debugging process can be supported by following an agent-oriented design methodology, and then using the developed design artifacts in the debugging phase. We propose a domain independent debugging framework which comprises the developed processes and components that are necessary in using design artifacts as debugging artifacts. Our approach is to take a non-formal design artifact, such as an AUML protocol design, and encode it in a machine interpretable manner such that the design can be used as a model of correct system behaviour. These models are used by a run-time debugging system to compare observed behaviour against specified behaviour. We provide details for transforming two design artifact types into equivalent debugging artifacts and show how these can be used to detect bugs. During a debugging episode in which a bug has been identified our debugging approach can provide detailed information about the possible reason for the bug occurring. To determine if this information was useful in helping to debug programs we undertook a thorough empirical study and identified that use of the debugging tool translated to an improvement in debugging performance. We conclude that the debugging techniques developed in this thesis provide effective debugging support for multi-agent systems and by having an extensible framework new design artifacts can be explored and as translations are developed they can be added to the debugging system

A Multi-Agent Approach for Designing Next Generation of Air Traffic Systems

This work was funded by Spanish Ministry of Economy and Competitiveness under grant TEC2011-28626 C01-C02, and by the Government of Madrid under grant S2009/TIC-1485 (CONTEXTS)