An event-driven high level model for the specification of laws in open multi-agent systems

Abstract

The agent development paradigm poses many challenges to software engineering researchers, particularly when the systems are distributed and open. They have little or no control over the actions that agents can perform. Laws are restrictions imposed by a control mechanism to deal with uncertainty and to promote open system dependability. In this paper, we present a high level event-driven conceptual model of laws. XMLaw is an alternative approach to specifying laws in open multi-agent systems that presents high level abstractions and a flexible underlying event-based model. Thus XMLaw allows for flexible composition of the elements from its conceptual model and is flexible enough to accept new elements.

Introduction

The agent development paradigm poses many challenges to software engineering researchers, particularly when the systems are distributed and open to accepting new modules that have been independently developed by third parties. Such systems have little or no control over the actions that agents can perform. As open distributed applications proliferate the need for dependable operation becomes essential.

There has been considerable research addressing the notion that the specification of such open multi-agent systems (MAS) should include laws that define behaviors in an open system (Carvalho et al., 2006a, Carvalho et al., 2006b, Carvalho et al., 2006c, Arcos et al., 2005). Laws are restrictions imposed by a control mechanism to tame uncertainty and to promote open system dependability (Minsky and Ungureanu, 2000, Paes et al., 2005). In this sense, such a mechanism should perform an active role in monitoring and verifying whether the behavior of agents is in conformance with the laws. We call this mechanism a governance mechanism. Examples of governance mechanisms are LGI (Minsky and Ungureanu, 2000), Islander (Esteva, 2003) and MLaw (Paes et al., 2006).

Governance for open multi-agent systems can be viewed as an approach that aims to establish and enforce some structure, set of norms or conventions to articulate or restrain interactions in order to make agents more effective in attaining their goals or more predictable (Lindermann et al., 2006).

A governance approach has to deal with two important issues: a conceptual model (also called a domain language, or meta model) and the implementation mechanism that supports the specification and enforcement of laws based on the conceptual model. The content of this paper is mainly about the former.

In the conceptual model, the approach describes what elements designers can use when specifying the law. The model specifies the vocabulary and the grammar (or rules) that designers can use to design and implement the laws. The model has a decisive impact on how easy it is to specify and maintain the laws. It is the approach to design that largely determines the complexity of the related software. When the software becomes too complex, the software can no longer be well enough understood to be easily changed or extended. By contrast, a good design can make opportunities out of those complex features (Domain Language Inc, 2007).

In 1987, Minsky published the first ideas about laws (Minsky and Rozenshtein, 1987) and in 2000, he published a seminal paper about the role of interaction laws on distributed systems (Minsky and Ungureanu, 2000), which he called Law-Governed Interaction (LGI). Since then he has conducted further work and experimentation based on those ideas (Murata et al., 2003, Minsky, 2003, Minsky, 2005). Although LGI can be used in a variety of application domains, its conceptual model is composed of abstractions basically related to low level information about communication issues (such as the primitives disconnected, reconnected, forward, and sending or receiving of messages). While it can be possible to specify complex interaction rules based on such low level abstractions, they may not be adequate for the design of the laws pertaining to complex systems. This inadequacy occurs because, once the laws in the domain level are mapped to the many low level primitives, the original idea of the law is lost, as it is spread over many low level primitives. This is basically the problem of having a language that provides abstractions that are too far removed from the domain. When developing complex interactive systems, we need higher-level abstractions to represent laws in order to reduce complexity and achieve resultant productivity.

The Electronic institution (EI) (Esteva, 2003) is another approach that provides support for interaction laws. An EI has a set of high level abstractions that allow for the specification of laws using concepts such as agent roles, norms and scenes. Historically, the first ideas appeared when the authors analyzed the fish market domain (Noriega, 1997). They realized that to achieve a certain degree of regulation over the actions of the agents, real world institutions are needed to define a set of behavioral rules, a set of workers (or staff agents), and a set of observers (or governors) that monitor and enforce the rules. Based on these ideas, they proposed a set of abstractions and a software implementation. However, although EI provides high level abstractions, its model is quite inflexible with respect to change. The property of flexibility is quite important since the research in interaction laws is under constant evolution, and consequently the model that represents the law abstractions and their underlying implementation should also be able to evolve. One example of evolution is the use of laws for providing support to the implementation of dependability concerns. In this situation, the monitoring of laws may allow the detection of unexpected behaviors of the system and corresponding recovery actions.

The question is how can a conceptual model of laws evolve if we do not know in advance the nature of the changes? The answer to this question is that there is no way to foresee which parts are going to change. However, it is possible to use a basic underlying model that is inherently flexible. Event-based systems lead to flexible systems mainly because they avoid direct dependencies among the modules. Instead, the dependency is between the modules and the events they produce or consume.

In general, event-driven software design avoids any direct connection between the unit in charge of executing an operation and those in charge of deciding when to execute it. Event-driven techniques lead to a low coupling among modules and have gained acceptance because of their help in building flexible system designs (Meyer, 2003). In an event-based architecture, software components interact by generating and consuming events. When an event in a component (called source) occurs, all other components (called recipients) that have declared interest in the event are notified. This paradigm appears to support a flexible and effective interaction among highly reconfigurable software components (Cugola et al., 1998), and has been applied successfully in very different domains, such as graphical user interfaces, complex distributed systems (Cugola et al., 1998), component-based systems (Almeida et al., 2006) and software integration (Meier and Cahill, 2005). Many of these approaches use event-based systems to manage changes in the software that cannot be anticipated during design (Almeida et al., 2006, Batista and Rodriguez, 2000). Such changes are generally driven by a better understanding of the domain, and by external factors (such as strategic, political or budget decisions).

In this paper, we present a high level event-driven conceptual model of laws. The focus is to highlight the “high level” and “event-driven” aspects of the model, instead of presenting in detail the model itself. We do not claim that the abstractions of the proposed conceptual model are better than the ones in related approaches. Instead, we claim that the model is composed of a rich set of high level abstractions which enable, for instance, the specification of complex laws that can even interact with many current technologies (such as web services). The model is specified based on the event-driven paradigm. As a result, new elements can be easily introduced in the model.

The idea is that each element should be able to listen to and generate events. For example, if the model has the notion of norms, then this norm element should generate events that are potentially important to other elements, such as lifecycle events, norm activation, sanction applications and so on. The norm is also able to listen for events generated by other elements of the conceptual model, and then can react accordingly. For example, if in the conceptual model there is an element that models the notion of time, such as an alarm clock, then norms may listen to alarm clock notifications and their behavior becomes sensitive to time variations. This leads to very flexible and powerful relationships among the elements. Furthermore, if there is a need to introduce a new element in the model, then most of the work is restricted to connecting this new element to the events to which it needs to react, and to discover which events this new element should propagate.

The flexibility achieved by using the event-driven approach at a high level of abstraction is not present in the other high level approaches (Esteva, 2003, Dignum et al., 2004). The advantages claimed by the use of events as a modeling element are also present in Minsky’s approach (Minsky and Ungureanu, 2000) as a low level of abstraction. In this paper, we show in detail how to map our high level approach to Minsky’s in such a way that we illustrate that we can also achieve all the results he has produced so far (we are not addressing efficiency and security issues).

At the implementation level, we have developed middleware that supports the interpretation and enforcement of the specification and treats each element of the conceptual model as a component that is able to generate and sense events. The presentation of the middleware implementation is outside the scope of this paper and can be found in Paes et al., 2006, Paes et al., 2007.

This paper is organized as follows. Section 2 shows the proposed solution as a step in solving the stated problem. In Section 3, we relate our research to previous work, explaining how the problem of flexibility and evolution has been addressed. Section 4 shows two case studies where the model is applied and compared to related work. Finally, in Section 5, we present some discussions about the contents of this paper and future work.