Declarative Negotiation Mechanism and the Auction Host (the Gatekeeper .... perspectives: application domain, functions, implementation technology, and ..... Briefly, achievement goals are, as their name states, means of achieving a desired.
Towards a Declarative Framework for the Specification of AgentDriven Auctions1 Alex Muscar and Costin Bădică
University of Craiova, Blvd. Decebal, nr. 107, RO-200440, Craiova, Romania, {amuscar,cbadica}@software.ucv.ro
Abstract: In this paper we propose a declarative framework for automated negotiation between software agents, The design space of automated negotiations is decomposed into: a minimal yet viable generic negotiation protocol, a declarative model of representing rules and constraints specific to each negotiation mechanisms and strategies, and a basic set of concepts for describing negotiations that form a core negotiation ontology that the agents can use to reason about the negotiations. We propose BeliefDesire-Intention agents as an implementation model of our framework. We introduce both our conceptual framework for declarative specification of automated negotiations, as well as a working prototype implementation based on the Jason agent programming language. Finally we present the details of the application of our framework for describing English and Dutch auctions.
1
Introduction An essential feature of agents is their ability to communicate by exchanging
meaningful information for improving their own goals and society goals. Sometimes agents behave selfishly and their goals are only partly overlapping or can even be in conflict. In such cases agents must interact to reach an agreement between all or some of the involved agents. These interactive processes are broadly called negotiations. Negotiations carried out between computer systems are known as automated This paper is an extended version of our conference paper: Muscar, A., Bădică, C.: Exploring the Design Space of a Declarative Framework for Automated Negotiation: Initial Considerations. In: Proc.8th IFIP WG 12.5 International Conference on Artificial Intelligence Applications and Innovations, AIAI 2012, Volume 381 of IFIP Advances in Information and Communication Technology, Springer (2012), 264– 273. 1
negotiations. There are two components of negotiation: mechanism and strategy. The negotiation mechanism states the interaction rules that must be obeyed by the participants in order to meet some objectives. The mechanism, sometimes known as protocol, is public. The negotiation strategy describes the behavior of a negotiation participant and it is directed towards reaching his or her private goals, usually to maximize his or her gain [1], [2]. Researchers proposed many models of automated negotiations. The models can be parameterized according to different criteria, like: number and roles of negotiation participants, structure and properties of the negotiation subject, presence or not of a mediator, a.o [3]. Some well-known automated negotiation models are: bargaining, auctions [4], multi-criteria negotiation [5], and multi-commodity negotiations. Based on our literature survey, we observed an important deficiency of existing research approaches to automated negotiation: they do not properly address the reusability and extensibility of the research results which are so much required for their usefulness in open environments such as the Internet and the Web. There are some specific research questions that immediately arise from this general problem. First, how can we define a reusable representation of automated negotiation protocols and strategies? Second, how can agents define and interpret their behaviors based on the formal representation of a negotiation mechanism? Finally, how can we capture and encode agents‘ knowledge about negotiation mechanisms such that they can adjust dynamically their strategies depending on needs? In this paper we propose some initial answers. First, inspired by [6], we identify a minimal2 yet viable generic negotiation protocol—the protocol actions can be used to model various negotiation types3. We also adopt a declarative approach of representing rules and constraints specific to negotiation types such that by combining them we can 2
Our prototype protocol defines only six actions (see Sec. 4.1).
3
English and Dutch auctions are considered in this paper as examples [7]
derive the basis of a generic, reusable negotiation framework. This would allow agents to specify and eventually reason about custom negotiation protocols and strategies. Second, we identify a set of core concepts related to negotiations that should be part of a core negotiation ontology that can be used by agents to reason about negotiations. Finally, we propose the Belief-Desire-Intention (BDI) model [8] as the basis for the design of our solution due to its suitable level of abstraction that can appropriately incorporate declarative specification of negotiation agents‘ behavior, thus offering a richer framework than existing proposals [9]. This work builds on and refines our previous efforts reported in [10] and [11]. While we acknowledge that our goal is very ambitious, we think that the research effort is worthwhile, as our endeavor can clearly contribute to the reusability of negotiation protocols and strategies, an issue that in our opinion was insufficiently explored by the research community. The main results consist of a conceptual framework for development of automated negotiations, as well as an initial prototype developed using Jason agent programming language [12]. While the implementation still lacks some of the features of our proposed conceptual framework, we believe it is a good starting point for the further exploration of the design space of declarative specifications of automated negotiations. Our choice for Jason as implementation language is motivated by the fact that Jason is probably the best known example of the BDI camp in the agent programming community and its support for a declarative programming style, closer to logic programming. We believe that the mix of declarative, goal-oriented, knowledge representation and meta-programming features of Jason make it a good candidate implementation language for our prototype. The paper is structured as follows. In Sec. 2 we set the stage by looking at some of the related research in this area. In Sec. 3 we outline our system architecture and go into more details regarding our proposed approach and at the same time illustrate our presentation with code samples from a prototype implementation. In Sec. 3 we look at the system as a whole, while in Sec. 4 we present the components of our generic model. Sec. 5 is dedicated to exploring the details of single agents in our framework. We conclude in
Sec. 6 and we also outline future research directions. 2
Background and Related Work There is a lot of work focused on agent-based auctions reported in the literature.
In this section we present an overview of some related literature in the area of auction specification (including rule-based and declarative methods) and generic auction architectures that are related to or even directly influenced our proposed approach. We also mention the main differences and advantages of our proposal. Authors of [6] proposed a generic software framework for automated negotiations. Although it is very interesting for our research, this proposal only addressed the problem from the perspective of the authority that controls the negotiation, i.e. the Auction Host. This approach is limited because, unlike a human negotiator, an artificial negotiator would have to be a priori designed to understand certain negotiation mechanisms. This is a considerable limitation of artificial agents as compared to humans, which leads to the impossibility of an artificial agent to act on a market whose negotiation mechanism is not known and understood before the agent design. Therefore, the perspective of the artificial agent acting as a participant in a negotiation should be also taken into account. As mentioned in Sec. 1, the work presented in this paper is a refinement of some of our earlier efforts in this research area, most notably [10] and [11]. The former presents an architectural model that is a refinement of the framework introduced in [6]. We adopt this model without any change, while focusing on a more detailed conceptualization of negotiations that is not present in that model (see Sec. 3.2). The latter introduces an earlier effort in the same direction as our own. As such, some conceptual and implementation details differ. First, the distinction between the Declarative Negotiation Mechanism and the Auction Host (the Gatekeeper agent in [11]) is not always clear, e.g. the Auction Host directly queries and manipulates negotiation specific data, thus making it less general than it is necessary. Second, the Generic Negotiation Protocol is unnecessarily split between the Auction Host and the Participant roles. Finally, the paper focuses mainly on the implementation of the prototype, and puts
less emphasis on the conceptual model. Our paper presents an updated, extended and mire detailed version of the conceptual model, while also reusing a part of that implementation since it was clear from [11] that Jason is a good fit for prototyping our system. Authors of [9] proposed the AB3D software framework for auction development. The AB3D system provides an auction specification framework, as well as a runtime system for the agents that enact the auction specifications. While this approach is interesting as it acknowledges the importance of generic, parameterizable auction specifications, we believe that the AB3D scripting language lacks with respect to flexibility when specifying participant strategies. The question of how a participant agent should dynamically understand the specification of a negotiation protocol (auction in particular) in order to define his strategy is not addressed by that work. The work introduced in [15] is probably the closest to our own. The authors describe a auction mechanism which revolves around two central concepts: the Descriptive Auction Language (DAL), and the DAL Market Server. The former is an XML language that allows the specification of auctions in a fine-grained manner, while the latter is the infrastructure that uses DAL specifications to create auction instances. The structure of DAL is based on the earlier work [16]. While superficially similar to AB3D, DAL is more flexible: instead of being a parametric approach (which is limited because there is only a finite number of parameters that can be taken into account by the designers of the language), DAL has a component oriented philosophy, where every component is self- contained and features a coherent description language of its own [15]. This approach allows components to be mixed and matched to obtain new auction specifications according to the needs of the auction designer. While clearly more flexible than AB3D, it is still centered around the market server. A recent and interesting example of BDI being used for automated negotiations is presented in [17]. The author proposes a multi-strategy automated negotiation framework based on the BDI model. While the presented approach is somewhat similar to our own in that it uses a specialization of the BDI model for the agents in the system, it differs in that
the author mostly focuses on individual agent‘s decision-making mechanism. While we acknowledge that this is an important aspect of an automated negotiation framework, we believe that the holistic approach we propose can lead to a truly generic solution. Nevertheless, the paper remains interesting, because it goes into much more detail w.r.t individual decision-making than the approach we are proposing and it might prove a valuable source of inspiration in our further efforts. Our generic negotiation model is quite similar to the Web Services Coordination (WS-Coordination) model [18]. Note that our Auction Host is in fact a coordinator according to WS-Coordination terminology that coordinates a seller and multiple buyer agents enrolled in an auction, while a coordination context closely corresponds to an auction instance. Nevertheless, while in [18] we were focused on the formal specification of the generic negotiation protocol using Finite State Process Algebra [19], in this paper we are providing insight into the detailed declarative specification of auction mechanisms (English and Dutch) and strategies using Jason agent programming language. A research that presents similar goals with our work was reported in paper [20]. Its authors are focused on defining a Negotiation Pattern Language – NPL that combines narrative descriptions, Role Activity Diagrams [21] and XML representation for describing reusable negotiation protocols. However, differently than our approach, this language is semi-formal and descriptive rather than declarative, and therefore it is not directly usable by software agents. Nevertheless, NPL proved useful for the definition of a pattern library that supports humans for understanding and applying successful negotiation protocols. Research reported in paper [22] proposes an ontology for formalizing auction patterns that combines an agreement pattern ontology and an auction ontology. However, this approach lacks a proper formalization. For example, the authors present a pattern for Vickrey auction described in a semi-formal natural language and then they jump from this description to an ontology representation using OWL [23]. This representation is useful for solving competency questions, like for example ―Which design patterns are available for a given task?‖ rather than for providing a declarative language directly
usable by software agents. An ambitious goal is set by authors of paper [13] for allowing agents to dynamically select and configure the negotiation protocol in open environments. The paper proposes that agents should advertise their negotiation protocols using a shared ontology of negotiation. By committing to high-level concepts defined by the shared ontology, agents can exchange negotiation information in a more facile and flexible way. However, differently from our work, the authors of paper [13] are more focused on discussing the ontological representation of negotiation mechanism using OWL and XML, rather than focusing on the details of how this representation can be used by the agent themselves. A survey of negotiation ontologies is provided by paper [14]. The authors reviewed and compared the most important works on negotiation ontologies from five perspectives: application domain, functions, implementation technology, and evaluation method and evaluation results. Nevertheless, this work was only a survey resulting in the proposal of a unifying annotation method for the integration of the surveyed approaches. Authors of paper [24] introduce a logic-based language for modeling alternatingoffers negotiations between multiple agents. The goal of their logic formalization is to analyze computational complexity classes of several agreement formation problems characterized by progressively more complex languages for negotiation. In particular the authors present logic formalizations of negotiation history and negotiation protocol that have similarities with our declarative specification approach. Nevertheless, our specification is directly executable by software agents. Moreover, our work addresses the broader class of generic auctions and thus we plan to consider more complex negotiation protocols than alternating offers. Authors of [25] proposed a method based on rule-based logic programming for the realization of agent-based trust management in an online auction. They represent role assignment and role-based access control policies as logic programs. A specialized module that can be part of the Auction Service, according to our model, enacts these policies. This module can serve each Auction Host to maintain the trustworthiness of each
auction. Its usefulness is mainly motivated for the detection of shill bidders – one of the mostly encountered trade frauds in online auctions. Similarly, in our approach the Auction Host uses logic programming rules to enforce the auction mechanism, thus assuring that bidders obey the bidding rules enforced by each specific auction. Paper [26] focuses on the formal representation of complex bidding strategies. Its authors proposed a visual method for specifying bidding strategies using a language inspired by UML activity diagrams [27] called Bidding Specification Language – BSL. Differently from our proposal, this work is focused only on the specification of the strategy of participant agents, thus ignoring the declarative specification of the auction mechanisms. Another notable difference is that authors of [26] present an operational implementation of a generic rule-based reasoning engine specialized for enacting the rule-based representation of strategies, while in our approach we reuse the well-known BDI reasoning model embedded into Jason agent programming language. Nevertheless, we consider that the investigation of a mapping of BSL onto Jason is worthy and thus, it was set as future work. Another path of research is the Emerald multi-agent framework for reasoning interoperability proposed by [28]. The framework includes a knowledge-customizable reusable agent prototype called KC-Agent. While the generic KC-agent model does not explicitly address negotiation, its architectural model provides a separation of the behavioral part represented as a set of Jess [29] rules from the agent belief part represented as a set of facts. This separation is particularly useful for defining customized knowledge-based negotiation strategies as sets of rules. Moreover, these rules may refer to specialized actions for agent communication that are useful for encoding the generic negotiation protocol. Another recent approach of developing automated negotiations using BDI agents was reported by [30]. There the BDI paradigm is applied in the context of unifying several Distributed Constraint Satisfaction Problem (DCSP) algorithms as a multilateral negotiation problem between BDI agents. The BDI paradigm proved useful for modeling the various agent action selection strategies during the distributed search process of
DCSP, which has similarities with the modeling of our custom negotiation strategies. 3
Generic Auction Model An automated negotiation can be studied and analyzed from two perspectives: the
perspective of the authority that controls the negotiation and the perspective of the negotiation participants, their preferences and their private strategies. Each perspective addresses one of the two components of an automated negotiation: negotiation mechanism and respectively negotiation strategy. The initial source of inspiration for our negotiation model is [6]. In that paper, the authors focused on auctions and performed a deeper analysis of the parameterization of the negotiation protocol by conceptually decomposing its semantic representation into several rule sets for: admission of participants to negotiation, proposal validity, protocol enforcement, updating negotiation status and informing participants, agreement formation, and controlling the lifecycle of the negotiation process. Although very interesting, their proposal is biased towards the perspective of the auction authority, but the implications of this approach for the participating agents are omitted from their analysis. In order to understand this point, it is useful to observe that a declarative specification can be utilized in two ways: as an enforcer, to constrain the participant agents behavior, as well as a generator of agents‘ permissible actions depending on the specific negotiation context. For example, let us consider the rules for proposal validity that constrain the submitted proposals to be consistent with a given template. According to [6], the auction authority will perform a consistency check of each proposal submitted by an auction participant. However, a participant agent can use this template to generate, whenever this is allowed by the protocol rules, a new proposal that is compliant with the proposal validity rules. Additionally, considering the rules for protocol enforcement, they might state that at some point a participant can either bid or leave the auction. The auction authority will use this information to check the messages received from a participant, recognizing and allowing only the actions of bidding or withdrawing (while an action for updating a
previously submitted bid would be rejected as not allowed), thus acting as enforcing mechanism for the auction semantics. The participant, on the other hand, will consider its options and, based on its custom strategy, it will pick up one of the two possible actions. From its perspective the negotiation mechanism will act as action generator. Incidentally, the custom strategy will act by additionally filtering the generated available options. We will get back to this point in Sec. 5. 3.1
Architectural Model We are going to use the architectural model introduced in [10] as the foundation
for our system architecture. This model is graphically illustrated in Fig. 1. The framework proposed by the authors features several types of agents (note that the initial framework targeted auctions, so we have used the term ―auction‖ interchangeably with ―negotiation‖):
Auction Service (AS) Usually it implements a specific type of auction. Its main purpose is to manage auction-related activities (e.g. creation, termination) and to coordinate the auction participants. AS registers with an Auction Service Directory (ASD, not shown on Fig. 1) that can be queried for a certain AS. An AS contains an Auction Directory (AD), which keeps track of all the ongoing auctions which are represented by Auction Instances (AI);
Auction Host (AH) It is an arbitrator agent responsible with coordinating the agents participating in a single AI. In order to accomplish this task, AH applies a specific mechanism for each auction type (e.g. English, Dutch).
Auction Participant (AP) This agent participates by bidding in an AI. Out of all the participants one is distinguished as the Auction Initiator Participant (AIP). We envision that an AP negotiation agent will use the framework to either initiate
a new negotiation or to register for bidding in an existing negotiation. For achieving these functions, the agent can be pre-designed to understand the negotiation mechanism (we already claimed that this is a considerable limitation) or it can download the declarative description of the negotiation mechanism from the Auction Service and apply it to define its private strategy. This second option is more interesting for the purpose of this paper.
For a more detailed presentation of this architecture and its application for the design and implementation of an auction server, please consult reference [10].
Fig. 1 Architectural Model
3.2
Conceptual Model We propose to conceptualize the declarative specification of a negotiation as
composed of three essential ingredients: Generic Negotiation Protocol (GNP), Declarative Negotiation Mechanism (DNM) and Custom Negotiation Strategy (CNS).
GNP Defines and governs the interaction between the participant agents and the host agent that are part of the system. It is the same for all participants independently of their specific role in the negotiation (i.e. buyer, seller). However, we will have a GNP part for the AH role, as well as a GNP part for the AP role; see Sec. 4.1 for more details);
DNM Is specific to a given negotiation type (e.g. English Auction, Continuous Double Auction, Iterative Bargaining). The DNM is usually defined using a declarative, Prolog-like language. The DNM serves to customize the GNP for representing the conditions and events that enable the permissible actions of negotiation agents (see Sec. 4.2 and Sec. 5 for more details); and
CNS Is specific to a given AP and must be consistent with the DNM. It is used by the AP to select and configure a specific negotiation action that could be most useful in a given negotiation context (see Sec. 4.3 for more details).
Based on the three features described above we can define the following metaphorical equations that more succinctly describe the agents present in our framework: AH = GNP + DNMhost AP = GNP + DNMparticipant + CNS These ingredients can be consistently bound into descriptions of AH and respectively AP behaviors by referring a common core vocabulary of terms for defining and parameterizing the space of negotiation types. This vocabulary is called Core Negotiation Ontology — CNO. The CNO can contain generic parameters, and actions. The former can be used to customize the auction, while the latter can be used by APs to choose corresponding actions with certain semantics for the auction. Another element of the CNO could be the types of rules used to guide action generation/selection during the negotiation process. The development of a comprehensive CNO is a complex task that is part of our future research and it is outside the scope of this paper. We are going to use the English and Dutch auctions as running examples for the following subsections, to give more insight into the three components introduced here. Therefore, for the purpose of this paper we are going to use a sample set of terms, mainly referring to negotiation actions available for English and Dutch auctions that will be introduced in Sec. 5. 4
Components of the Generic Model
4.1 Generic Negotiation Protocol The GNP describes the permissible negotiation conversations involving a set of agents comprising the following two generic roles: the role of AH — there is a single agent playing this role in a negotiation — and the role of AP — there are one or more agents playing this role in a negotiation. Thus the GNP is agnostic of any details that are specific to a particular negotiation type. All participants are guaranteed to expose at least this functionality. This is somewhat similar to an abstract type. In this view the AH is a
Fig. 2 The Generic Negotiation Protocol
service provider exposing the GNP interface, whereas the AP is the client. Figure 2 illustrates this relation. Because the GNP is auction agnostic, the specific details of a certain negotiation type are captured and declaratively represented with the help of the DNM. GNP is inspired by our previous work [10]. As part of the GNP we identified a set of actions as sufficient for introducing the proof-of-concept implementation:
register used by an AP to register itself with a specific auction host;
bid used to place a bid;
inform/query depending on the push/pull semantics desired, the AH will disseminate
auction information to the participants via tell or ask actions;
fold used by the participant to get out of an auction;
close used by the auction host to end the auction;
winner used by the auction host to notify the winning participants. Note that the actions described above are defined at the conceptual level, and as
such they are independent of the Agent Communication Language (ACL) used by the implementation. Our prototype implementation uses the Jason ACL for implementing the GNP actions. The authors of [6] use FIPA ACL [31] for describing their protocol. This is also possible for our approach, should the need arise, since every action in our protocol
could be mapped to one or a couple of FIPA ACL messages. Table 1 illustrates one possible mapping. GNP action name
FIPA ACL performative(s)
register
PROPOSE; ACCEPT_PROPOSAL; REJECT_PROPOSAL
bid
PROPOSE; ACCEPT_PROPOSAL; REJECT_PROPOSAL
inform/query
INFORM; REQUEST
fold
REQUEST; CONFIRM; REFUSE
close
INFORM
winner
INFORM Table. 1 FIPA ACL mappings of GNP actions
Just like [6], our hypothetical mapping to FIPA ACL uses the PROPOSE and ACCEPT_PROPOSAL / REJECT_PROPOSAL pair for the registration and bidding phases since this is the most natural choice. Information dissemination can be mapped to either the INFORM or the REQUEST actions depending on the desired semantics, i.e. push or pull. Withdrawal from a negotiation is translated as a REQUEST that can be either confirmed (CONFIRM) or refused (REFUSE) by the auction host depending on the DNM rules. Finally, closing the negotiation and informing the winner is translated trivially by using the INFORM action from FIPA ACL. It is conceivable that the close and winner actions could be folded into one action, close with an additional parameter identifying the winner or the lack thereof. At this point of our investigation we decided to keep the distinction in the formal model since there are some types of auctions that do not have a winner, e.g. Dutch auctions, and the parameter to the close action would be meaningless. There are also some auctions where there can be a winner after each round, i.e. the clearing phase occurs multiple times, thus the phases of closing de bid and choosing a winner are not one and the same. Such examples are continuous double auctions. As an example, this distinction is also made by [9].
Action name
Entity
register
Participant
bid
Participant
inform/query
Auction Host / Participant
fold
Participant
close
Auction Host
winner
Auction Host
Table. 2 GNP actions and the entities that perform them
4.2 Declarative Negotiation Mechanism Conceptually DNM is defined on top and orthogonal to the GNP and it semantically enhances the GNP. So the DNM together with the GNP define a specific negotiation protocol. However, this specification is still non-deterministic, meaning that the actual behavior description of an AP agent must be supplemented with a CNS and thus it is defined by the triplet GNP, DNM and CNS. The DNM is acting as an enforcer on the AH side, i.e. it simply checks the AP behavior according to the protocol rules, and as a generator of agent actions on the AP side. Note that this view can be easily materialized as an executable specification in a logic programming language, for example Prolog [32], Jess [29] or Jason. 4.3 Custom Negotiation Strategy Each individual AP agent must implement the CNS. In particular, this component allows each AP to adopt different risk attitudes toward the auction participation (e.g. eager, aggressive, neutral). As mentioned before, this is a key aspect of our approach, since it allows modeling much richer negotiation scenarios. So, in principle, CNS should be not only understandable and adjustable by the AP itself, but also externally configurable by a human user which can be present behind a certain AP.
Conceptually, the CNS is built on top of the GNP and DNM, so the strategy designer is not exposed to the lower level encoding of the negotiation process. Instead he or she can focus on the more relevant aspects of the definition of an appropriate strategy — like improving his or her outcome from the negotiation participation. 5 Prototype Implementation Note that although our conceptual model is mature enough, the proposed implementation using Jason is just an initial prototype. Its further extension and evaluation are required as part of our future work.4 5.1 Brief Review of Jason and BDI Paradigm Jason is an agent-oriented programming language based on AgentSpeak(L) [33] with some extensions. It is based on the BDI paradigm, in which agents are programmed in terms of beliefs, desires and intentions. An agent has a reasoning cycle during which it perceives new events, and based on them and its mental state (i.e. its current beliefs) it generates a series of intentions that can be carried out by plans. See [8, p. 7] for an indepth description. We will now briefly introduce the details necessary to understand the code samples from the following sections. A Jason program is formed of beliefs, rules, and plans. Beliefs are similar to Prolog facts, and rules are similar to Prolog relations [32]. There are two major differences: the Jason rule language supports strong negation, introduced by the ‗ ‘ prefix operator, e g raining asserts that we definitely know the fact that it is not raining, and conjunction is expressed with the aid of the ‗&‘ operator instead of ‗,‘ as in Prolog Plans are meant to define agent behavior for handling events, and have the following form: triggering_event : context
