Ricardo Choren

A UML Based Approach for Modeling and Implementing Multi-Agent Systems

In this paper we present an agent-oriented modeling language, called MAS-ML, and an approach for mapping its diagrams into Java implementations. MAS-ML extends the UML meta-model describing new meta-classes and stereotypes, extending the class and sequence diagrams and proposing two new diagrams: organization and role diagram. The paper also relates MAS-ML to other modeling languages that also extend the UML for modeling multi-agent systems.

MAS-ML: a multiagent system modelling language

Multiagent System Modelling Language (MAS-ML) provides a conservative extension to the Unified Modeling Language (UML) 2.1 metamodel in order to accommodate agent-related abstractions such as roles, organisations, plans and protocols. In this paper we present the MAS-ML metamodel by detailing the new concepts introduced in the UML metamodel. In addition, the paper illustrates the new model elements and summarises the three MAS-ML structural diagrams and the two MAS-ML dynamic diagrams.

Using the MAS-ML to model a multi-agent system

The current object-oriented development practice system analysis is documented through UML artifacts such as Class and Sequence diagrams. Since UML is a widely accepted modeling language, it also would be desirable to offer a UML support for the representation of agent-based system analysis artifacts. Although some central UML constructs are suitably matched for agent-based modeling, several improvements must be made to the UML meta-model to achieve this new goal. This paper presents MAS-ML, a UML extension for agent-based system modeling. The use of MAS-ML for modeling agent-based systems is presented with a simple illustrating application.

Enhancing agent-oriented models with aspects

The modular representation of concerns is imperative in the design modeling of multi-agent systems (MASs). However, MAS designers typically face a number of concerns that inherently affect several system agents and their respective internal elements, such as actions and goals. These crosscutting concerns encompass both internal and systemic properties, such as learning, mobility, error handling, and security. Without an explicit modeling of such MAS properties, designers can not properly communicate and reason about them and their broadly-scoped effects. The result is a multitude of agent-oriented design breakdowns: poor traceability from requirements to design models, hindering of reuse opportunities, and decreased evolvability. This paper presents an enhancement of an existing agent-oriented modeling language with aspects. We illustrate the use of our approach through some classical examples of crosscutting concerns in agent-oriented design models.

Modeling Multi-agent systems with ANote

An important issue in getting the agent technology into mainstream software development is the development of appropriate methodologies for developing agent-oriented systems. This paper presents an approach to model distributed systems based on a goal-oriented requirements acquisition. These models are acquired as instances of a conceptual meta-model. The latter can be represented as a graph where each node captures a concept such as, e.g., goal, action, agent, or scenario, and where the edges capture semantic links between such abstractions. This approach is supported by a modeling language, the ANote, which presents views that capture the most important modeling aspects according to the concept currently under consideration.

Using agents and ontologies for application development on the semantic web

The Semantic Web provides access to heterogeneous, distributed information, enabling software products to mediate between user needs and the information sources available. Agents are one of the most promising technologies for the development of Semantic Web software products. However, agent-based technologies will not become widespread until there are adequate infrastructures for the development of semantic multi-agent systems (MAS). Some challenges, such as turning software agents into practical abstractions for dealing with ontologies, taking advantage of the distributed nature of the Web to create distributed agents and making a seamless integration with existing Web tools, e.g. the browser, still need to be addressed. This paper describes the main features of the SemantiCore framework, an agent infrastructure to develop semantic MAS. A look at a benchmark Semantic Web application illustrates the SemantiCore potential as an infrastructure for the deployment of semantic agent applications.

Enhancing the environment with a law-governed service for monitoring and enforcing behavior in open multi-agent systems

Environment is an essential part of any multi-agent system (MAS), since it provides the surrounding conditions for agents to exist. For some sort of systems, the environment can be viewed as providing a set of services, in which some of them, such as directory facilities, are used explicitly by the agents to perform their tasks, and other such as monitoring, behavioral enforcement and security can be done transparently by the environment. We join the idea that the specification of environments of open multi-agent systems should include laws that define what and when something can happen in an open system. Laws are restrictions imposed by the environment to tame uncertainty and to promote open system dependability. This paper proposes a design approach and application of a middleware based on laws in multi-agent systems. The approach can be viewed as a set of services provided by the environment.

The ANote modeling language for agent-oriented specification

Multi-agent systems are distributed systems of loosely coupled agents. Description and construction of these systems are eased by separating their structure from their dynamic behavior. ANote is a modeling language for multi-agent system analysis that supports this approach. It provides a notation language which supports multi-agent system analysis through its decomposition into structural and behavioral views. Each view is responsible for picturing an important aspect, while ignoring less important details. This paper describes the ANote notation language and its views. The notation language is described and illustrated by an example, an e-insurance system.

An approach to reduce the gap between conceptual and execution models in agent-directed simulations

The Agent-Oriented Paradigm has been used to successfully develop simulations as executions models. These models are derived from the models generated in the design of simulation. A useful model used to design simulations are the conceptual model, that is a theoretical construct for represent the simulated system in a static way. Thus, changes in the conceptual model demand changes in the Multi-Agent simulation code. This paper presents an approach to tame this problem by representing the conceptual model in an ontology and by proposing a Multi-Agent architecture that is able to interpret the model and execute the simulation. This allows for more independence between the simulation concepts and the simulation engine.

An aspect-oriented modeling framework for multi-agent systems design

A number of concerns in multi-agent system (MAS)design have a crosscutting impact on agent-oriented models. These concerns inherently affect several system agents and their internal modeling elements, such as actions and goals. Examples of crosscutting concerns in MAS design encompass both internal and systemic properties, such as learning, mobility, error handling, and security. Without an explicit modeling of such MAS properties, designers can not properly communicate and reason about them and their broadly-scoped effects. This paper pre sents a meta-modeling framework for supporting the modular representation of crosscutting concerns in agent-oriented design. The framework is centered on the notion of aspects to describe these concerns. It also defines new composition op-erators to enable the specification on how aspects affect the agent goals and ac-tions. The proposed framework is a result of our previous experience in both using aspect-oriented techniques for MAS design and implementation, and integrating aspect-oriented abstractions in an agent-oriented modeling language, called ANote.