nach oben

2010 | Buch

Kapitel lesen Erstes Kapitel lesen

Languages, Methodologies, and Development Tools for Multi-Agent Systems

Second International Workshop, LADS 2009, Torino, Italy, September 7-9, 2009, Revised Selected Papers

herausgegeben von: Mehdi Dastani, Amal El Fallah Segrouchni, João Leite, Paolo Torroni

Verlag: Springer Berlin Heidelberg

Buchreihe : Lecture Notes in Computer Science

Enthalten in: Springer Professional "Wirtschaft+Technik" , Springer Professional "Technik" , Springer Professional "Wirtschaft"

Einloggen, um Zugang zu erhalten

Über dieses Buch

This book contains the proceedings of the Second International Workshop on Languages, Methodologies and Development Tools for Multi-agent Systems (LADS 2009), which took place during September 7–9, 2009 in Turin, Italy. As in its 2007 edition, this workshop was a part of MALLOW, a federation of workshops on Multi-Agent Logics, Languages, and Organizations. The LADS 2009 workshop addressed both theoretical and practical issues related to developing and deploying multi-agent systems. It constituted a rich forum where leading researchers from both academia and industry could share their experiencesonformalapproaches,programminglanguages,methodologies, tools andtechniques supporting the developmentanddeploymentof multi-agent systems.Fromatheoreticalpointofview,LADS2009aimedataddressingissues related to theories, methodologies, models and approaches that are needed to facilitate the development of multi-agent systems ensuring their predictability andveri?cation.Formaldeclarativemodelsandapproacheshavethe potentialof o?ering solutions for the speci?cation and design of multi-agent systems. From a practical point of view, LADS 2009 aimed at stimulating research and d- cussion on how multi-agent system speci?cations and designs can be e?ectively implemented and tested. This book is the result of a strict selection and review process. From 14 papers originally submitted to LADS 2009, and after 2 rounds of reviews, we selected 10 high-quality papers covering important topics related to multi-agent programming technology, such as: agent architectures, programming languages andmethodologies,socialinteractionmodels,developmenttoolsandapplications of multi-agent systems.

Inhaltsverzeichnis

Frontmatter

Agent Architectures

The ARTS Real-Time Agent Architecture

Abstract

We present a new approach to providing soft real-time guarantees for Belief-Desire-Intention (BDI) agents. We define what it means for BDI agents to operate in real time, or to satisfy real-time guarantees. We then develop a model of real-time performance which takes into account the time by which a task should be performed and the relative priority of tasks, and identify the key stages in a BDI architecture which must be bounded for real-time performance. As an illustration of our approach we introduce a new BDI architecture, ARTS, which allows the development of agents that guarantee (soft) real-time performance. ARTS extends ideas from PRS and JAM to include goals and plans which have deadlines and priorities, and schedules intentions so as to achieve a priority-maximal set of intentions by their deadlines.

Konstantin Vikhorev, Natasha Alechina, Brian Logan

Reducing Agent Plans to Workflows

Abstract

In this paper, we introduce an agent planner architecture that can reduce the basic artifacts of agent planning paradigms, semantic services and business process languages into a common workflow model. These artifacts are then executed by means of a workflow component that the architecture includes. By having a workflow component in an agent infrastructure, various agent programming paradigms including different planning approaches as well as different workflow definition languages can be executed on the same agent platform. To illustrate our ideas, we focus on the reduction of plans to the workflow model. To explicate the reduction mechanism, we have preferred to use HTN which is a widely known planning approach in multi-agent domain. Based on the semantics that we have defined for our workflow and HTN models, we have given an algorithm for transformation from HTN to workflow model.

Tayfun Gokmen Halaç, Övünç Çetin, Erdem Eser Ekinci, Rıza Cenk Erdur, Oğuz Dikenelli

Agent Programming Languages and Methodologies

Externalisation and Internalization: A New Perspective on Agent Modularisation in Multi-Agent System Programming

Abstract

Agent modularisation is a main issue in agent and multi-agent system programming. Existing solutions typically propose constructs such as capabilities to group and encapsulate in well-defined modules inside the agent different kinds of agent features, that depend on the architecture or model adopted—examples are goals, beliefs, intentions, skills. In this paper we introduce a further perspective, which can be considered complimentary to existing approaches, which accounts for externalizing some of such functionalities into the computational environment where agents are (logically) situated. This leads to some benefits in terms of reusability, dynamic extensibility and openness. To this end, we exploit artifact-based computational environments as introduced by the A&A meta-model and implemented in CArtAgO technology: agent modules are realised as suitably designed artifacts that agents can dynamically exploit as external tools to enhance their action repertoire and – more generally – their capability to execute tasks. Then, to let agent (and agent programmers) exploit such capabilities abstracting from the low-level mechanics of artifact management and use, we exploit the dual notion of internalization, which consists in dynamically consulting and automatically embedding high-level usage protocols described in artifact manuals as agent plans. The idea is discussed providing some practical examples of use, based on CArtAgO as technology for programming artifacts and Jason agent platform to program the agents.

Alessandro Ricci, Michele Piunti, Mirko Viroli

Temporal Planning in Dynamic Environments for P-CLAIM Agents

Abstract

Time and uncertainty of the environment are very important aspects in the development of real world applications. Another important issue for the real world agents is, the balance between deliberation and reactivity. But most of the agent oriented programming languages ignore some or all of these important aspects. In this paper we try to fill this gap by presenting an extension to the architecture of CLAIM agent oriented programming language to endow the agents with the planning capability. We remove the assumption that agents’ actions are instantaneous. We are interested in the temporal planning of on the fly goals. A coherrent framework is proposed in which agents are able to generate, monitor and repair their temporal plans. Our proposed framework creates a balance between reactivity and deliberation. This work could be considered as a first step towards a complete temporal planning solution for an AOP language.

Muhammad Adnan Hashmi, Amal El Fallah Seghrouchni

Data Driven Language for Agents Secure Interaction

Abstract

This paper discusses the security issues in data driven coordination languages. These languages rely on a data space shared by the agents and used to coordinate their activities. We extend these languages with a main distinguishing feature, which is the possibility to define fine-grained state-based security conditions, associated with every datum in the shared space. Two main ideas makes it possible: the consideration of an abstraction of agents’ states in the form of data at language level and the introduction of a richer interaction mechanism than state-of-the-art templates. This novel security mechanism allows both agents and system designers to prohibit undesirable interactions.

Mahdi Zargayouna, Flavien Balbo, Serge Haddad

Programming Social Middleware through Social Interaction Types

Abstract

This paper describes a type-oriented approach to the programming of social middleware. It defines a collection of metamodeling features which allow programmers to declare the social entity types which make up the program of a multiagent society for some application domain. These features are identified and formalised taking into account a specification of social middleware as programmable, abstract machines. Thus, the proposed approach results in the type system of an interaction-oriented programming language. The paper uses the C+ action language and the CCalc tool as formal devices, so that metamodeling features are given formal semantics as new social law abbreviations which complement the causal law abbreviations of C+. This programming language approach contrasts with the informal modeling approach endorsed by organizational methodologies, and promotes higher levels of formality, modularity and reusability in the specification of multiagent societies.

Juan Manuel Serrano, Sergio Saugar

Social Interaction Models

Detecting Exceptions in Commitment Protocols: Discovering Hidden States

Abstract

Open multiagent systems consist of autonomous agents that are built by different vendors. In principle, open multiagent systems cannot provide any guarantees about the behaviors of their agents. This means that when agents are working together, such as carrying out a business protocol, one agent’s misbehavior may potentially create an exception for another agent and obstruct its proper working. Faced with such an exception, an agent should be able to identify the problem by verifying the compliance of other agents.

Previous work on verification of protocols unrealistically assume that participants have full knowledge of a protocol. However, when multiple agents enact a protocol, each agent has access to its part of the protocol and not more. This will require agents to check verification by querying others and more importantly by discovering the contracts between them. Here, we propose a commitment-based framework for detecting exceptions in which an agent augments its part of the protocol with its knowledge to construct states that are previously hidden to the agent by generating possible commitments between other agents. The agent then queries others to confirm those states. Our framework is built using C+ and Java, and is tested using a realistic delivery scenario.

Özgür Kafalı, Pınar Yolum

Verifiable Semantic Model for Agent Interactions Using Social Commitments

Abstract

Existing approaches about defining formal semantics of commitment usually consider operations as axioms or constrains on top of the commitment semantics, which fail to capture the meaning of interactions that are central to real-life business scenarios. Furthermore, existing semantic frameworks using different logics do not gather the full semantics of commitment operations and semantics of social commitments within the same framework. This paper develops a novel unified semantic model for social commitments and their operations. It proposes a logical model based on a new logic extending CTL ^* with commitments and operations to specify agent interactions. We also propose a new definition of assignment and delegation operations by considering the relationship between the original and new commitment contents. We prove that the proposed model satisfies some properties that are desirable when modeling agent interactions in MASs and introduce a NetBill protocol as a running example to clarify the automatic verification of this model. Finally, we present an implementation and report on experimental results of this protocol using the NuSMV and MCMAS symbolic model checkers.

Mohamed El-Menshawy, Jamal Bentahar, Rachida Dssouli

Development Tools for Multi-agent Systems

Call Graph Profiling for Multi Agent Systems

Abstract

The design, implementation and testing of Multi Agent Systems is typically a very complex task. While a number of specialist agent programming languages and toolkits have been created to aid in the development of such systems, the provision of associated development tools still lags behind those available for other programming paradigms. This includes tools such as debuggers and profilers to help analyse system behaviour, performance and efficiency. AgentSpotter is a profiling tool designed specifically to operate on the concepts of agent-oriented programming. This paper extends previous work on AgentSpotter by discussing its Call Graph View, which presents system performance information, with reference to the communication between the agents in the system. This is aimed at aiding developers in examining the effect that agent communication has on the processing requirements of the system.

Dinh Doan Van Bien, David Lillis, Rem W. Collier

Applications

A Methodology for Developing Self-explaining Agents for Virtual Training

Abstract

Intelligent agents are used to generate the behavior of characters in virtual training systems. To increase trainees’ insight in played training sessions, agents can be equipped with capabilities to explain the reasons for their actions. By using an agent programming language in which declarative aspects of an agent’s reasoning process are explicitly represented, explanations revealing the underlying motivations for agents’ actions can be obtained. In this paper, a methodology for developing self-explaining agents in virtual training systems is proposed, resulting in agents that can explain their actions in terms of beliefs and goals.

Maaike Harbers, Karel van den Bosch, John-Jules Meyer

Backmatter

Titel: Languages, Methodologies, and Development Tools for Multi-Agent Systems
herausgegeben von: Mehdi Dastani
Amal El Fallah Segrouchni
João Leite
Paolo Torroni
Verlag: Springer Berlin Heidelberg
Electronic ISBN: 978-3-642-13338-1
Print ISBN: 978-3-642-13337-4
DOI: https://doi.org/10.1007/978-3-642-13338-1