In this paper, we present a complete view of an agent-oriented software engineering methodology called agent systems engineering methodology ( ASEME ). Several parts of the methodology concerning different aspects of the whole development process have already been published in the past in several papers. However, our goal in this paper is to provide a global view on the methodology by providing information about the agent (and multi-agent systems) development process along with recent works concerning the tools that we have developed in order to facilitate the use of ASEME by agent systems developers. We also provide some information on the different practical applications that we have developed using ASEME and which prove that ASEME is very well suited for the development of real world applications.
Deliberation over goals is a fundamental feature of intelligent agent systems. In this article we provide pragmatic but principled mechanisms for quantifying the level of completeness of goals in a belief-desire-intention (BDI) agent. Our approach leverages previous work on resource and effects summarisation which we extend by accommodating both dynamic resource summaries and goal effects, while also allowing a non-binary quantification of goal completeness. We treat both goals of accomplishment (achievement goals) and goals of monitoring (maintenance goals). We reconcile such practical computation of progress estimates of goals of both types with an earlier theoretical perspective on BDI goal completeness, and thus extend the theoretical framework to include maintenance goals. Our computational mechanisms have been implemented in the abstract agent language CAN. We also provide a detailed example in an autonomous rover domain.
DIVAs is a generic multi-agent-based simulation framework (MABS) for the development of simulation systems. In DIVAs, agents are situated in an open environment that is partially perceived, and the environment is totally decoupled from agents. DIVAs provides a set of reusable architectures, abstract and concrete classes, software components, and tools for the definition of agents and open environments, a microkernel for the management of the simulation workflow, domain-specific libraries for the rapid development of simulations, and reusable and extendable components for the control and visualisation of simulations. Also, DIVAs offers the means to dynamically access and modify agent and environment properties at run-time. This paper discusses the DIVAs' reference architecture and outlines its major design decisions.
This paper concerns methodology for evaluating task-oriented personal assistants, where users perform a complex task that has objective success criteria, independent of personal preferences, and the agent provides suggestions to help users repeatedly perform the task consistently and accurately. We develop a systematic approach to evaluating task-oriented personal assistants in normal contexts of use through extending the methodology of empirical software engineering to evaluate effectiveness, efficiency and satisfaction. The approach allows the evaluation of both the human-agent system and of the personal assistant using data obtained by observations of user and system behaviour. A key element of our approach is to define empirically observable conditions that separate the learning period, when users and the agent are learning to perform the task, from the evaluation period, when performance benefits are measured. The methodology is illustrated using the example of a system for users to extract, annotate and code events from news articles.
SARL is a general-purpose agent-oriented programming language. This language aims at providing the fundamental abstractions for dealing with concurrency, distribution, interaction, decentralisation, reactivity, autonomy and dynamic reconfiguration that are usually considered essential for implementing agent-based applications. Every programming language specifies an execution model. In the case of SARL, this execution model is defined based on the object-oriented paradigm, i.e., the run-time environment is written in Java. Accordingly, and by default, the SARL programs are transformed into their equivalent object-oriented programs written in Java. The goal of this paper is twofold. Firstly, to explain the mapping between the agent-oriented paradigm and the object-oriented paradigm. Secondly, to define transformations from the SARL constructs to the Java constructs. We advocate that these goals enable the SARL developers to understand the SARL statements, and the mapping to the equivalent executable entities.
Mobile location-sharing technology is used increasingly by parents to know where their children are. It is our aim to make such technology more flexible in adapting to the particular social context in which it operates. We propose to realise this by allowing users to specify norms that govern the respective social contexts, to which the application should adapt at run-time to provide tailored support. The challenge we address in this paper is the development of a normative model tailored for mobile applications that support location sharing in family life. The novelty of our work lies in the fact that we employ empirical user-centred design methods and techniques for developing the model in an iterative and 'bottom-up' way. This results in two main contributions: 1) a normative model, specifically a social commitment model, for family life location sharing applications shown to be useful and usable, and 2) a demonstration of how user-centred design can be employed to develop a normative model for social applications.
The language mechanisms protocol and role are used in order to organise the interaction structures between agents in multi-agent systems. Agents are internally organised by means of roles, roles are related as protocols, and agents send messages to each other through their related roles. The comprehensive and complex interaction structures between agents are conceptualised by protocol and role, and these abstraction mechanisms are used in the description of interaction structures. The description of the interaction structures between agents becomes understandable and the development process of multi-agent systems becomes efficient and flexible. The language mechanisms are illustrated by means of a supporting application framework.
Due to their immense complexity, large-scale multi-agent systems are often not amenable to exhaustive formal verification. Statistical approaches that focus on the verification of individual traces can provide an interesting alternative that circumvents combinatorial explosion. However, due to its focus on finite execution paths, trace-based verification is inherently limited to certain types of correctness properties. We show how, by combining sampling with the idea of trace fragmentation, statistical verification can be used to answer interesting quantitative correctness questions about multi-agent systems at different observational levels. The usefulness of the verification approach is illustrated with a simple case study from the area of swarm robotics.
This paper presents the workings of the Flisvos-2017 multi-agent system that participated in the Multi-Agent Programming Contest MAPC 2017 of Clausthal TU.
Debugging is notoriously difficult and extremely time consuming but also essential for ensuring the reliability and quality of a software system. In order to reduce debugging effort and enable automated failure detection, we propose an automated testing framework for detecting failures in cognitive agent programs. Our approach is based on the assumption that modules within such programs are a natural unit for testing. We identify a minimal set of temporal operators that enable the specification of test conditions and show that the test language is sufficiently expressive for detecting all failures in an existing failure taxonomy. We also introduce an approach for specifying test templates that supports a programmer in writing tests. Furthermore, empirical analysis of agent programs allows us to evaluate whether our approach using test templates detects all failures.
We provide a detailed description of the Python-DTU system, including the overall system design and the tools used in the agent contest.
We present the twelfth edition of the Multi-Agent Programming Contest (https://multiagentcontest.org), an annual, community-serving competition that attracts groups from all over the world. Our contest facilitates comparison of multi-agent systems and provides a concrete problem that is interesting in itself and well-suited to be tackled in educational environments. This time, seven teams competed using strictly agent-based as well as traditional programming approaches.
We provide a brief description of the Python-DTU system, including the overall design, the tools and the algorithms that we plan to use in the agent contest.
Remote patient monitoring (RPM) enables physicians to perform diagnosis and treatment remotely through sensors connected via a communication network. Dependability and flexibility are recognised as two key technological requirements for RPM take off. In this paper we address the questions of how RPM systems designed and implemented as multiagent systems (MASs) can ensure flexibility and dependability, and which agent-oriented approach is more suitable to achieve this goal. We analysed five state-of-the-art agent-oriented approaches according to ten features. Since no approach among the five clearly dominates the others, we selected the one we are more familiar with, parametric trace expressions. We used them to verify properties modelling existing medical guidelines and to develop a prototype where newborns suffering from hypoglycemia must be continuously monitored, showing how agentoriented approaches in general, and parametric trace expressions in particular, are suitable for engineering flexible and dependable RPM systems.
With the explosion of the internet of things, it is critical to decide which connected devices can be used by an application in order to achieve its objectives, while maintaining user information privacy. In this paper we propose a solution for the configuration and the deployment of distributed applications in smart environments that takes into consideration device heterogeneity, the dynamics of the environment and the need for resource privacy. The key points of our solution are: 1) an ontology allowing the description of the environment (the hardware entities and the applications to be deployed) using graphs; 2) a distributed algorithm capable of reasoning on these descriptions to decide which hardware entities of the infrastructure have to be used to deploy a specific application; 3) a goal-directed multi-agent system as a well-adapted paradigm to provide a clear separation between the applicative and the infrastructure layers.
There are many examples where large amount of data might be potentially accessible to an agent, but the agent is constrained by the available budget since access to knowledge bases is subject to fees. There are also several activities that an agent might perform on the web where one or more stages imply the payment of fees: for instance, buying resources in a cloud computing context where the objective of the agent is to obtain the best possible configuration of a certain application withing given budget constraints. In this paper we consider the software-engineering problem of how to practically empower agents with the capability to perform such kind of reasoning in a uniform and principled way. To this aim, we enhance the ACE component-based agent architecture by means of a device for practical and computationally affordable quantitative reasoning, whose results actually determine one or more courses of agent’s actions, also according to policies/preferences.
One of the BDI paradigm's major concerns is the lack of control over the agents' perceptions. Without having any form of goal-directed perceptions, agents may be flooded by irrelevant information thus causing an unjustified increase in processing time. This issue becomes critical when one needs to develop agents to be integrated with virtual environments or simulators, or even in the case of embedded agents, as robots. In order to provide greater control on the agents' perceptions and to reduce their time response, this work proposes to incorporate a filtering perception mechanism within the Jason interpreter, aiming to eliminate irrelevant perceptions in order to reduce processing time. To this end, some types of pre-defined filters proposed in the literature have been implemented and their effect experimentally evaluated in three different simulated and one embedded agent experiments. Using a full factorial experiment design, a technique used in computer systems performance analysis, it was shown that applying perception filters can reduce up to 80% of an agent's processing time, without significantly affecting its performance measured in terms of its utility function.
This paper contributes with a decentralised agent design for a microgrid that uses agent technology for avoiding dumping the excess of energy to a main powerline. The agent design is made with INGENIAS. The agents connect with a microgrid simulator, the SGSimulator and issue commands to control different distributed renewable energy sources. The paper illustrates the benefits of coordination of agents in such scenario through a simple token based protocol.
There has been considerable progress in both the theory and practice of agent programming since Georgeff and Rao's seminal work on the belief-desire-intention paradigm. However, despite increasing interest in the development of autonomous systems, applications of agent programming are confined to a small number of niche areas and adoption of agent programming languages in mainstream software development remains limited. This state of affairs is widely acknowledged within the community and a number of reasons and remedies have been proposed. In this paper, I present an analysis of why agent programming has failed to make an impact that is rooted in the class of programming problems agent programming sets out to solve, namely the realisation of flexible intelligent behaviour in dynamic and unpredictable environments. Based on this analysis, I outline some suggestions for the future direction of agent programming and some principles that I believe any successful future direction must follow.
When designing agent-oriented software, engineers should consider performance-related non-functional requirements. To this end, performance engineering practices provide a useful toolbox. In particular, simulation of the system's processes appears eminently suitable. Agent-oriented software engineering methodologies are not directly linked to process simulation features. This paper extends an AOSE methodology for transforming agent roles models to process models, and for streamlining the transformation process towards simulation. Our method allows process model generation, aiming to support the process simulation, and was integrated into a model-driven engineering methodology. We used an established process modelling notation (BPMN) as the target language for the process model, and we are able to deliver a ready-to-simulate model. Through simulation, an analyst can validate specific system requirements and test scenarios of how the system scales beyond the current requirements. Furthermore, because of process models familiarity within the business domain, engineers, managers and stakeholders can seamlessly communicate system designs.
