C. Sierra and Colleagues, Electronic
C. Sierra and Colleagues, Negotiation.
International Conference of Logic Programming and Constraint Programming,
Paphos, Cyprus with associated workshops Computational Logic and Multi-Agent
Systems (CLIMA) and Logic-Based Program Synthesis and Transformation (LoPSTr).
The 4th workshop of the UK Special Interest Group in Multi-Agent Systems
(UKMAS), Oxford, UK.
Ninth International SPIN Workshop on Model Checking of Software, Grenoble,
The Evolutionary Computing and Multi-Agent Systems (ECOMAS) conference,
New York, USA.
International Conference on Multi-Agent Systems (ICMAS) in Boston.
The International Conference on Autonomous Agents (Agents) in Montreal.
Our annual project workshop at ETAPS.
The ARO/NSF ``Monterey'' workshop: Modelling Software System Scenarios
in a Fast Moving Scenario, Santa Margarita Ligure, Italy.
D. Robertson, Experimental
Analysis for Large Agent Systems, In: Procs.
of Modelling Software System Structures in a Fastly Moving Scenario.
D. Robertson, A
Lightweight System, Presented at the SLIE Annual Review Meeting, Madrid,
Spain, 21 June 2001.
J. Sabater, Design
Rules, Presented at the SLIE Annual Review Meeting, Madrid, Spain,
21 June 2001.
C. Sierra, Institutions,
Presented at the SLIE Annual Review Meeting, Madrid, Spain, 21 June 2001.
J. Sabater, Laboratory
Framework, Presented at the SLIE Annual Review Meeting, Madrid, Spain,
21 June 2001.
W. Vasconcelos, Laboratory
Framework, Presented at the SLIE Annual Review Meeting, Madrid, Spain,
21 June 2001.
C. Walton, Review
of Systems for Validation, Presented at the SLIE Annual Review Meeting,
Madrid, Spain, 21 June 2001.
S. Parsons and M. Wooldridge,
Design Methods, Presented at the SLIE Annual Review Meeting, Madrid,
Spain, 21 June 2001.
All project software can be found at source forge. Stephen Phelps is the admin
& Assorted Documents
We propose a logic-based rendition of electronic institutions - these are means to specify open agent organisations. We employ a simple notation based on first-order logic and set theory to represent an expressive class of electronic institutions. We also provide a formal semantics to our constructs and present a distributed implementation of a platform to enact electronic institutions specified in our formalism.
Communication is the key feature of
Multi-agent Systems. The interactions among components of a system may
take many distinct forms of increasing complexity such as in auctions,
negotiations, and argumentations. In this paper we propose a notation
to specify and reason about an expressive class of protocols. Our
notation is logic-based, employing a restricted form of first-order
constructs added with sets. We formally associate the syntax of our
constructs with a precise semantics. The semantics enables us to
automatically build explicit models which can be used to restrict the
possible executions of a given Multi-Agent System. Our notation has
been incorporated to a variant of electronic institutions - an
encompassing and flexible approach to specify open agent organisation
- and we have implemented a proof-of-concept platform to enact
arbitrary protocols using our notation.
Prototyping is a valuable technique
to help software engineers explore the design space while gaining insight on the dynamics of the system. In this paper, we describe a method for rapidly building prototypes of large multi-agent systems using logic programming. Our method advocates the use of a description of all permitted interactions among the components of the system, that is, the protocol, as the starting specification. The protocol is represented in a way that allows us to automatically check for desirable properties of the system to be built. We then employ the same specification to synthesise agents that will correctly follow the protocol. These synthesised agents are simple logic programs that engineers can further customise into more sophisticated software. Our choice of agents as logic programs allows us to provide semi-automatic support for the customisation activity. In our method, a prototype is a protocol with a set of synthesised and custonmised agents. Executing the prototype amounts to having these agents enact the protocol. We have implemented and describe a distributed platform to simulate prototypes.
The use of previous direct interactions is probably the best way to calculate a reputation but, unfortunately this information is not always available. This is especially true in large multi-agent systems where interaction is scarce. In this paper we present a reputation system that takes advantage, among other things, of social relations between agents to overcome this problem.
Social network analysis has been used for a long time by sociologist as a mechanism to infer and explain social behaviours. Analysing social relations between individuals in a society using social network analysis techniques allows to identify a lot of features of that society that can be very valuable in an e-commerce environment. In this paper we describe how these techniques can be used to improve a reputation system and also how this system can be integrated with a negotiation model to increase the success of negotiations.
The general goal of the research reported in this paper is to better understand the dynamics of large Multi-Agent Systems (or MAS, for short) with globally distributed and interconnected collections of human, software and hardware systems; each one of which with potentially thousands of components. This paper explores two ideas. First, a particular approach to the principled design of MAS using Equation- Based Models (EBM) as a high level speci cation method, where equations model the aggregated behaviour of the agent populations abstracting from the interaction details of individual agents (Section 2). Second, the use of evolutionary computation techniques to nd out what agent structures produce the global emergent behaviour speci ed in the EBM (Section 3). These ideas are framed within a design methodology called SADDE (Social Agents Design Driven by Equations).
In this paper we describe an approach for semi-automatic agent development. We focus on the scenario in which agents are designed to follow an electronic institution, a formalism to specify open agent organisations. In our approach, an initial design pattern is automatically extracted from a given electronic institution. This pattern is then offered to programmers willing to develop agents to perform in the electronic institution. Our approach supports developers when modifying the initial simple design pattern into more sophisticated programs.
Engineering individual components of a multi-agent system and their interactions is a complex and error-prone task in urgent need of methods and tools. Prototyping is a
valuable technique to help software engineers explore the design space while gaining insight and a "feel" for the dynamics of the system; prototyping also allows
engineers to learn more about the relationships among design features and the desired computational behaviour. In this paper we describe an approach to building
prototypes of large multi-agent systems with which we can experiment and analyse results. We have implemented an environment embodying our approach. This
environment is supported by a distributed platform that helps us achieve controlled simulations.
MABLE is a language for the design and automatic verification of multi-agent systems. MABLE is essentially a conventional imperative programming language, enriched by constructs from the agent-oriented
programming paradigm. A MABLE system contains a number of agents, programmed using the MABLE imperative programming language. Agents in MABLE have a mental state consisting of beliefs, desires and
intentions. Agents communicate using request and inform performatives, in the style of the fipa agent communication language. MABLE systems may be augmented by the addition of formal claims about the
system, expressed using a quantified, linear temporal belief-desire-intention logic. MABLE has been fully implemented, and makes use of the spin model checker to automatically verify the truth or falsity of claims.
Mechanism design is the economic theory of the design of effective resource allocation mechanisms, such as auctions. Traditionally, economists have approached design problems by studying the analytic properties of different mechanisms. An alternative is to view a mechanism as the outcome of some evolutionary process involving buyers, sellers, and the auctioneer. As a first step in this alternative direction, we have applied genetic programming to the development of an auction pricing rule for double auctions in a wholesale electricity marketplace. For this purpose we adopted the multi-agent simulation model of Nicolaisen, Petrov, and Tesfatsion.
Auctions can be thought of as resource allocation mechanisms. The economic theory behind such systems is mechanism design. Traditionally, economists have approached design problems by studying the analytic properties of different mechanisms. An alternative is to view a mechanism as the outcome of some evolutionary process involving buyers, sellers, and an auctioneer. As a first step in this alternative direction, we have applied genetic programming to the development of an auction pricing rule for double auctions in a wholesale electricity marketplace.
Model checking as an approach to the automatic verification of finite state systems has focused predominantly on system specifications expressed in temporal logic. In the distributed systems community, logic of knowledge (epistemic logics) have been advocated for expressing desirable properties of protocols and systems. A range of logics combining temporal and epistemic components have been developed for this purpose. However, the model checking problem for temporal logics of knowledge has received (comparatively) little attention. In this paper, we address ourselves to this problem. Following a brief survey of the relevant issues and literature, we introduce a temporal logic of knowledge. We then develop an approach to CKL model checking that combines ideas from the interpreted systems semantics for knowledge with the logic of local propositions developed by Engelhardt et al. With our approach, local propositions provide a means to reduce CKL model checking to linear temporal logic model checking. After introducing and exploring the ideas underpinning our approach, we present a case study ( the bit transmission problem) in which SPIN was used to establish temporal espistemic properties of a system implemented in PROMELA.
M-P.Huget, M.Esteva, S.Phelps,
C.Sierra, and M.Wooldridge, Model checking Electronic Institutions, In:
proceedings of the Workshop on Model Checking and AI, Toulouse, France,
In this paper we present ISLANDER, a tool for the specification and verification of agent mediated electronic institutions.We have defined a textual declarative language for the specification of the components of an institution. Also an ISLANDER editor is presented. It facilitates the work of the institution designer permitting the combination of graphical and textual specifications. We take the stance that a verifiable formal specification is needed before starting the development of complex systems. This tool is our first step towards having a framework for the design and development of infrastructures for open multi-agent systems.
N.R.Jennings, P.Faratin, A.R.Lomuscio,
S.Parsons, M.Wooldridge and C. Sierra,Automated
Negotiation: Prospects, Methods and Challenges,In: Journal of Group
Decision and Negotiation, 10, 199-215, 2001
An increasing number of computer systems are being viewed in terms of autonomous agents. These agents are clearly identifiable problem solving entities with well defined boundaries and interfaces, situated in particular environments, and with their own goals to achieve. The autonomy of the agents implies that they have control over their own execution and so cannot be made to do what other agents wish them to do. Instead inter-agent dependencies have to be managed through negotiation. This paper takes a wide-ranging look at the state of the art in negotiation between autonomous agents, and discusses the work of the authors within this context.
M. Wooldridge and S. Parsons,
On the Design of Negotiation Protocols for Logic-based Agent Communication
Languages, In: F. Dignum, editor, Agent-Mediated Electronic Commerce III,
This paper considers the design of negotiation protocols for logic-based agent communication languages. We begin by motivating the use of such languages, and introducing a formal model of logic-based negotiation. Using this model, we define two important computational problems: the success problem (given a particular negotiation history, has agreement been reached?) and the guaranteed success problem (does a particular negotiation protocol guarantee that agreement will be reached?) We then consider a series of progressively more complex negotiation languages, and consider the complexity of using these languages. We conclude with a discussion on related work and issues for the future.
Argumentation is one of the most preomising approaches tohandling inconsistency in knowledge bases. It consists of constricting arguments and counter-arguments (defeaters) and then selecting the most acceptable of them. In previous work a preference-based argumentation framework was proposed. In that framework theknowledge base is supposed to be equipped with a preordering over the beliefs. However there are limits towhat can be achieved with this framework since it does not takeinto account the case where several preorderings on the beliefs (contextual preferences) are avilable. the aimof this paper is to extend the framework defined in previous work in order to reason from multiple points of view on an inconsistent knowledge base.
This paper considers the use of logic-based languages for multi-agent negotiation. We begin by motivating the use of such languages, and introducing a formal model of logic-based negotiation. Using this model, we define two important computational problems: the success problem (given a particular negotiation history, has agreement been reached?) and the guaranteed success problem (does a particular negotiation protocol guarantee that agreement will be reached?) We then consider a series of progressively more complex negotiation languages, and consider the complexity of using these languages. We conclude with a discussion on related work and issues for the future.
A number of authors have suggested the use of argumentation techniques as the basis for negotiation dialogues between agents. In this paper we augment this work by investigating the use of argumentation as the basis for a wider range of types of dialogue. The approach we take is based upon MacKenzie's dialogue game DC, and we show that a translation of this into our system of argumentation can support a subset of the types of dialogue identified by Walton and Krabbe.
Reputation has been studied in many elds but few formal models have been de ned up to now. In this paper we propose a new model for reputation that takes into account the social dimension of agents and a hierarchical ontology structure. This model is a natural extension of other models currently being used in the area of electronic commerce. We show how the model relates to these other systems and provide initial experimental results about the bene ts of using a social view on the modeling of reputation.
This paper considers the use of logic-based languages for multiagent negotiation. We begin by motivating the use of such languages, and introducing a formal model of logic-based negotiation. Using this model, we define two important computational problems: the success problem (given a particular negotiation history, has agreement been reached?) and the guaranteed success problem (does a particular negotiation protocol guarantee that agreement will be reached?) We then consider a series of progressively more complex negotiation languages, and consider the complexity of using these languages. We conclude with a discussion on related work and issues for the future.
This extended abstract gives a basic introduction to the aims of a new project, funded by the European Commission, on the experimental analysis of large multi-agent systems. The project involves the University of Edinburgh (Anderson, Fourman, Robertson, Sannella, Vasconcelos, Walton), the Institute for Artificial Intelligence in Barcelona (Agusti, Sabater, Sierra) and the University of Liverpool (Parsons, Wooldrifge).
Our aim is to define a simple framework withing which software practicioners can set up experiements using populations of agents. The envisaged scenario of our framework is one in which a designer of Multi-Agent Systems wishes to experiment with a view to understand the dynamics of populations of agents.
We describe a simple and practical implementation for a generic agent interpreter in Prolog. To achieve the desiravle asynchronicity of distinct agents as well as to allow for actual message-passing among them we make use of a standard technology for distributed/parallel computation in Prolog. We also present LPad a tool to support the automatic upload and execution of a number of agents using our implementation proposal.
Logic, in its broadest sense and diversity, has been successfully employed to investigate important issues of multi-agent systems. However, it is most desirable that we offer means to simulate the intended behaviours of the systems modelled via such logical approaches. In this paper we present an extensible simulation platform in Prolog for logic-based multi-agent systems.
The Open Source Software (OSS) movement has recently gained much popularity as an alternative method of software development. The basic tenets of OSS development are open source code, free redistribution, and non-restrictive licensing. OSS proponents argue that this approach is faster, more efficient, and leads to a better quality code. With such successes as Linux and Apache to its name, OSS is now beginning to attract serious attention from the commercial software industry.
The OSS community is a good instance of an information ecosystem. The OSS enviornment is one which facilitates rapid evolution and change. Consequently, there are many OSS projects with differing behaviours and organisational structures. New OSS projects are constantly being born, and a signigicant number also fail. In this paper we examine three large OSS projects: Linux, Apache, and Mozilla. Each of these projects displays a different social organisation, and is driven by forces depending on the niche the product is intended to fill. For each project, we discuss the enviornment and development process employed, and examine the factors which drive change in this enviornment. These include both nourishing factors and hazards. We then outline a model of the project as a multi-agent ecosystem which may be used to guide an empiricial analysis. Finally we examine the process by which changes are integrated into the ecosystem and how the potential threats are overcome.
Two key issues in building multi-agent systems concern their scalability and engineering open systems. We offer solutions to these potential problems by introducing a lifecycle for models of large multi-agent systems. Our proposal connects a model for the collective analysis of agent systems with an individual-based model. This approach leads on to a virtuous cycle in which individual behaviours can be mapped on to global models and vice-versa. We illustrate our approach with a formal example but relatively easy for engineers to follow and adapt.
In this paper we investigate three distinct approaches to the simulation of multi-agent systems: sequential, multi-processing and multi-threading. A standard inter-agent communication platform has been additionally connected to the multi-threading execution approach making it robust and generic. For each approach we present its advantages and drawbacks and elaborate on the tools we have built.