Applications in mobile multi-agent systems require a high degree of confidence that code that runs inside the system will not be malicious and that any agents which are malicious can be identified and contained. Since the inception of mobile agents, this threat has been addressed using a multitude of techniques, but many of these implementations have only addressed concerns from the position of either the platform or the agent, and very few approaches have undertaken the problem of mobile agent security from both perspectives simultaneously. Furthermore, no middleware exists that facilitates provision of the required security qualities of mobile agent software while extensively focusing on easing the software development burden. In this paper, we introduce a mobile agent system that enhances security functionality by integrating core software and hardware assurance qualities, as well as addressing security concerns from the perspectives of both the platform and the agent.
Handling erroneous conditions in context-aware mobile agent systems is challenging due to their intrinsic characteristics: openness, lack of structuring, mobility, asynchrony, and increased unpredictability. Even though several context-aware middleware systems support now the development of mobile agent-based applications, they rarely provide explicit and adequate features for context-aware exception handling. This paper reports our experience in implementing error handling strategies in some prototype context-aware collaborative applications built with the MoCA (Mobile Collaboration Architecture) system. MoCA is a publish-subscribe middleware supporting the development of collaborative mobile applications by incorporating explicit services to empower software agents with context-awareness. We propose a novel context-aware exception handling mechanism and discuss some lessons learned during its integration in the MoCA infrastructure. The discussions include how to use other emerging implementation techniques, such as aspect-oriented programming, to address the limitations of classical publish-subscribe mechanisms identified in our study.
With the introduction of large-scale open systems, the need for managing interactions between agents, and in particular for managing the entry of a new agent into an existing system, becomes an increasingly more important objective. Without such management, there may be significant implications for the performance of such systems, negating the benefits to be gained from openness. In this paper, we sketch a process by which open multi-agent systems may be engineered, through the establishment of a system specification to be used by designers of agents that will enter the system, and by the system itself to check that an agent entering a system complies with the system constraints. While not fully detailed, the paper provides an initial model and a clear direction as to how such a system may be constructed, offering a new way of developing open multi-agent systems.
Agents provide developers with a flexible way to structure systems around autonomous, communicating elements. To support the efficient development of such systems, design techniques need to be introduced. In this context, we propose an extension of the UML 2.0 metamodel to support agency features and UML-based diagrams which can be used to capture four views of multi-agent systems architecture (Architectural, Intentional, Environmental and Communication). The approach also provides heuristics to guide the description of multi-agent systems according to the proposed diagrams in the context of the Tropos framework. To illustrate the approach we present an Electronic Newspaper example.
Multi-Agent Systems (MAS) are collection of loosely coupled intelligent agents. These systems operate in a distributed, highly dynamic, unpredictable and unreliable environment in order to meet their overall goals. Agents in such an environment are vulnerable to different types of run time exceptions. It is necessary to have an effective exception diagnosis and resolution mechanism in place in order to ensure reliable interactions between agents. In this paper, we propose novel exception diagnosis architecture for open MAS. The proposed architecture classifies the runtime exceptions and diagnoses the underlying causes of exceptions using a heuristic classification technique. The proposed architecture is realised in terms of specialised exception diagnosing agents known as sentinel agents. The sentinel agents act as delegates of problem solving agents and mediate interactions between them.
The software agent paradigm has received considerable attention recently, both in research and industrial practice. However, adoption of this software paradigm remains elusive in software engineering practice. We claim that part of the adoption problem lies with the fact that mentalistic and social concepts underlying agents are subjective and complex for the average practitioner. Specifically, although there are many efforts related to the topic coming from philosophy, cognitive sciences and computer science, a uniform and well-founded semantic view on these concepts is currently lacking. This work extends an existing upper-level ontology and offers it as a foundation for evaluating and designing agent-oriented modeling languages. In particular, the paper focuses on the concept of goal, aiming at disambiguating its definition, discussing its different manifestations, and clarifying its relation to other important agent-related concepts. For that, we examine how goals are conceived and used according to some relevant literature on agent-orientation. In addition, related work on akin fields, especially philosophy and AI are used as a basis for the proposed ontological extensions.
To achieve the goal of realizing object adaptation to environments, a new role-based model Epsilonand a language EpsilonJare proposed. In Epsilon, an environment is defined as a field of collaboration between roles and an object adapts to the environment assuming one of the roles. Objects can freely enter or leave environments and belong to multiple environments at a time so that dynamic adaptation or evolution of objects is realized. Environments and roles are the first class constructs at runtime as well as at model description time so that separation of concerns is not only materialized as a static structure but also observable as behaviors. Environments encapsulating collaboration are independent reuse components to be deployed separately from objects. In this paper, the Epsilon model and the language are explained with some examples. The effectiveness of the model is illustrated by a case study on the problem of integrated systems. Implementation of the language is also reported.
Handling erroneous conditions in context-aware mobile agent systems is challenging due to their intrinsic characteristics: openness, lack of structuring, mobility, asynchrony and increased unpredictability. Even though several context-aware middleware systems now support the development of mobile agent-based applications, they rarely provide explicit and adequate features for context-aware exception handling. This paper reports our experience in implementing error handling strategies in some prototype context-aware collaborative applications built with the MoCA (Mobile Collaboration Architecture) system. MoCA is a publish-subscribe middleware supporting the development of collaborative mobile applications by providing explicit services that empower software agents with context-awareness. We propose a novel context-aware exception handling mechanism and discuss some lessons learned during its integration in the MoCA infrastructure.
The paper introduces the Cama (Context-Aware Mobile Agents) framework intended for developing large-scale mobile applications using the agent paradigm. Cama provides a powerful set of abstractions, a supporting middleware and an adaptation layer allowing developers to address the main characteristics of the mobile applications: openness, asynchronous and anonymous communication, fault tolerance, device mobility. It ensures recursive system structuring using location, scope, agent and role abstractions. Cama supports system fault tolerance through exception handling and structured agent coordination. The applicability of the framework is demonstrated using an ambient lecture scenario - the first part of an ongoing work on a series of ambient campus applications.
In this paper, we present an object-oriented framework for situated multiagent systems. The framework integrates various mechanisms for adaptivity we have developed and applied in our research, including selective perception, protocol-based communication, behavior-based decision making with roles and situated commitments, and laws that mediate the activities of agents in the environment. The framework provides a reusable design asset that facilitates the development of new multiagent system applications that share the common base more reliable and cost efficiently. We give an overview of the framework, and we zoom in on two particular features: decision making with a free-flow tree and support for simultaneous actions. Finally, we show how the framework is applied to an experimental robot application.
In this paper, we present a unit testing approach for MASs based on the use of Mock Agents. Each Mock Agent is responsible for testing a single role of an agent under successful and exceptional scenarios. Aspect-oriented techniques are used, in our testing approach, to monitor and control the execution of asynchronous test cases. We present an implementation of our approach on top of JADE platform, and show how we extended JUnit test framework in order to execute JADE test cases.
Multi-agent systems must be engineered to ensure that desirable system-level properties will consistently emerge from the complex interactions of the underlying agents, while also guaranteeing that undesirable behavior will be suppressed. We present an Aspect-Oriented Programming (AOP) framework for modeling, visualizing and manipulating emergent structure in multi-agent systems. By encapsulating the macroscopic structure, we can identify undesirable patterns of behavior at a higher level of abstraction. The identification of such patterns allows us to implement a feedback loop to steer the behavior of the lower level agents towards actions favorable for the emergence of a reliable solution. AOP facilitates the modeling of the system-wide behavior, thus it serves as a valuable tool for building confidence that a given multi-agent system will consistently meet its requirements.
Agents provide developers with a flexible way of structuring systems around autonomous, communicative elements. In order to support the efficient development of such systems, design techniques need to be introduced. In this context, we propose a set of UML-based diagrams which can be used to capture structural and behavioral features of the Belief-Desire-Intention agent model. The approach aims at supporting detailed architectural design of multi-agent systems by providing a process to guide the description of agent roles according to the proposed diagrams in the context of the Tropos framework. To illustrate the approach we present a Conference Management System case study.
The dependability of open multi-agent systems is a particular concern, notably because of their main characteristics as decentralization and no single point of control. This paper describes an approach to increase the availability of such systems through a technique of fault tolerance known as agent replication, and to increase their reliability through a mechanism of agent interaction regulation called law enforcement mechanism. Therefore, we combine two frameworks: one for law enforcement, named XMLaw, and another for agent adaptive replication, named DimaX, in which the decision of replicating an agent is based on a dynamic estimation of its criticality. Moreover, we will describe how we can reuse some of the information expressed by laws in order to help at the estimation of agent criticality, thus providing a better integration of the two frameworks. At the end of the paper, we recommend a means to specify criticality monitoring variation through a structured argumentation approach that documents the rationale around the decisions of the law elements derivation.
Fault tolerance is an important property of large-scale multi-agent systems as the failure rate grows with both the number of the hosts and deployed agents, and the duration of computation. Several approaches have been introduced to deal with some aspects of the fault-tolerance problem. However, most existing solutions are ad hoc. Thus, no existing multi-agent architecture or platform provides a fault-tolerance service that can be used to facilitate the design and implementation of reliable multi-agent systems. So, we have developed a fault-tolerant multi-agent platform (named DimaX). DimaX deals with fail-stop failures like bugs and/or breakdown machines. It brings fault-tolerance for multi-agent applications by using replication techniques. It is based on a replication framework (named DARX).
Effective fault-handling in emerging complex applications in large-scale MAS (Multi-agent Systems) requires the ability to dynamically adapt resource allocation and fault tolerance policies in response to changes in environment, user or application requirements, and available resources. This adaptation process incorporates an observation mechanism that transparently monitors the application's behaviors as well as the availability of resources, and adaptively reconfigures the system resources. This process is realized by a specific module which exploits the information resulting from monitoring. In this paper, we present an approach for adaptive replication. This approach uses an observation mechanism and a feedback control system within an adaptive replication infrastructure to support adaptive fault tolerance in multi-agent organizations. The main strategy used in our approach is to insert control theory methodology and analysis to adaptive replication. Thus, our approach provides a systematic and scientific method for implementing adaptive fault tolerance policies in MAS.
The i* Strategic Dependency model has been successfully employed to analyze trust relationships of networks of agents during the early stages of multiagent systems development. However, the model only supports limited trust reasoning due to its limitation to deal with the vulnerability of the depender regarding the failure of the dependency. In this paper, we introduce the concept of willingness, which provides a solution to the above problem and therefore allows a more complete analysis and reasoning of trust relationships in networks of agents.
As new software demands and requirements appear, the system and its interaction laws must evolve to support these changes. Languages and models should provide the tools for dealing with this evolution. Poor support for evolution has a negative impact on system maintainability. In this paper, we propose some refinement operators to extend the interaction laws in open multi-agent systems. As an example of this idea, we implemented a customizable application in the supply chain management domain as an open system environment.
The Mission Control Technologies Project at NASA Ames Research Center is developing component-based middleware with multi-agent like characteristics that must satisfy many competing quality attributes. This paper makes the observation that, while a multi-agent system solution is a relevant source of architecture and design artifacts, it is not possible to achieve the desired system quality attributes with a purely MAS implementation. MAS frameworks offer agents as the primary unit of decomposition and encapsulation. The degree of agency is also selected by framework developers - indicating that the agent abstraction is not considered a point of framework variability. We introduce the notion of engineering degrees of agency into an application framework by designing points of variability (hooks) that enable a programmer to tune the degree of agency used through customizations of the agent abstraction.
Exception handling has a commonly agreed semantics in many programming languages. When an operation is called with inappropriate conditions, the control flow of the program is reversed back to the caller to trigger some handling mechanisms. In Multi-Agent Systems (MAS), this semantics applies to the code of agents, but it does not cover the kind of exceptions that occur at the agent level. For instance, the usual handling semantics does not address the cases where the plan of an agent fails and re-planning is required. In fact, the agent code does not necessarily encounter a programming fault or a `catch' clause in such a case, but the agent has yet to deal with an exceptional situation.In this paper, we survey the literature on exception handling with the aim to demonstrate that research needs to be conducted in the case of MAS due to their openness, heterogeneity, and the encapsulation of agents. We identify research directions from the survey, and we present a simulation scenario to illustrate the occurrence of agent-level exceptions in a simple case. The current result of the survey analysis is that agent exceptions mechanisms should rely on the proactivity of agents, on exploiting the agent environment, on collaborative handling mechanisms, and on the potential links between code-level and agent-level exceptions.
