a formal approach to negotiating agents development

Electronic Commerce Research and Applications 1 (2002) 193–207

www.elsevier.com/ locate/ecra

A formal approach to negotiating agents developmenta , b a a*Marlon Dumas , Guido Governatori , Arthur H.M. ter Hofstede , Phillipa Oaks

aCentre for Information Technology Innovation, Queensland University of Technology, GPO Box 2434, Brisbane, Queensland 4001,Australia

bSchool of ITEE, University of Queensland, Brisbane, Queensland 4072, Australia

Abstract

This paper presents a formal and executable approach to capture the behaviour of parties involved in a negotiation. Aparty is modeled as a negotiating agent composed of a communication module, a control module, a reasoning module, and aknowledge base. The control module is expressed as astatechart, and the reasoning module as adefeasible logic program. Astrategy specification therefore consists of a statechart, a set of defeasible rules, and a set of initial facts. Such a specificationcan be dynamically plugged into an agent shell incorporating a statechart interpreter and a defeasible logic inference engine,in order to yield an agent capable of participating in a given type of negotiations. The choice of statecharts and defeasiblelogic with respect to other formalisms is justified against a set of desirable criteria, and their suitability is illustrated throughconcrete examples of bidding and multi-lateral bargaining scenarios. 2002 Elsevier Science B.V. All rights reserved.

Keywords: Automated negotiation; Software agent; Defeasible logic; Statecharts

1 . Introduction have been studied by the game-theory and thedistributed artificial intelligence communities [2–5].

As the amount of commercial transactions carried Furthermore, several tournaments where automatedout through the Internet increases at a spectacular traders compete to maximize their profits in elec-rate, the interest for partially or totally automating tronic auction houses have been organized [6,7], andthe negotiation of the terms of these transactions has their results are quite encouraging.rapidly become a hot research topic. Consequently, Software agents are becoming a choice technologyautomated negotiation has evolved in a few years for carrying out automated negotiations [3]. In thisfrom a futuristic vision to a promising technology approach, each party is represented through an agent[1]. In particular, optimal strategies for several forms which interacts either directly with the other parties,of automated bargaining and auctioning under sim- or through a broker. The behaviour of the agent isplifying assumptions have been identified, and the guided by astrategy, which may be as simple asextensions of these results to more realistic settings continuously increasing the current offer by the

minimum increment up to a maximum amount (e.g.in the context of an English auction or a bargainingscenario), or as complex as determining the next*Corresponding author.

E-mail address: [email protected](M. Dumas). offer based on an analysis of the history of all the

1567-4223/02/$ – see front matter 2002 Elsevier Science B.V. All rights reserved.PI I : S1567-4223( 02 )00016-9

mailto:[email protected]

194 M. Dumas et al. / Electronic Commerce Research and Applications 1 (2002) 193–207

previous offers and even that of previous negotia- An important feature of the above approach is thattions [8,9]. The issue in this context is thus ‘how to it leads to plug-and-play negotiation strategy spe-express a negotiation strategy?’. cifications. Indeed, given an agent shell capable of

An approach developed at MIT’s Kasbah project interpreting statecharts and defeasible logic pro-[10] in the setting of English auctions, is to provide a grams, it is possible to dynamically plug a strategyset of simple pre-defined strategies, corresponding to specification into this shell, so as to obtain alinear, quadratic and exponential functions over time. negotiating agent.The authors argue that using pre-defined strategies To validate the viability of our approach, we havehas the advantage that it makes the bidding agents’ applied it to several case-studies. In this paper, wedecisions easily explainable and predictable. How- develop two of them in details: one concerning anever, this approach considerably restricts the possi- English auction, and the other one concerning abilities of the users. In particular, it is not applicable one-to-many bargaining scenario, where one buyerwhen the users’ valuation of the auctioned item simultaneously bargains with several potential sellersdepends upon that of the other bidders (i.e. in in order to find an acceptable deal. This validationcorrelated-value auctions [3]), since in this case, the work follows the preliminary results presented inbidding function should dynamically adapt to the [14], where we show how defeasible logic can beother participants’ bids. In addition, the use of this used to express strategies for brokered trading, andapproach in a broader setting than English auctions, for a simple case of bargaining.implies that there will be one set of alternative The paper is structured as follows. In Section 2,strategies for each negotiation protocol (i.e. one set we introduce our approach and justify our choicesof agents for each variant of the double auction, against a set of design criteria. Next, in Section 3, weanother for each kind of bargaining, etc.). develop two case-studies, respectively, involving an

At the other extreme, each participant involved in English auction and a bargaining scenario. Finally, ina negotiation could develop its own negotiating agent Section 4 we compare our proposal to related ones,‘from scratch’, using a general-purpose design meth- before concluding in Section 5.odology and development environment (see [11] fora list of agent building tools). Although this approachis unavoidable when very complex strategies are 2 . Rationale, approach, and enabling formalismsconsidered, its systematic use leads to time-consum-ing and hard-to-reuse development efforts. In addi- 2 .1. Desideratation, agents developed under this approach havestatic functionalities, in the sense that it is often not Before choosing one or several languages for thepossible to modify their behaviour without having to specification of negotiation strategies, it is importantrebuild them from scratch. to establish a set of criteria that such languages need

As an alternative to these extreme approaches, our to satisfy. The criteria presented below are inspiredaim is to develop a simple yet expressive framework from those formulated by ter Hofstede [15] in thefor specifying negotiating agents’ strategies, in a way context of techniques for information modelling.that their decisions are predictable and explainable. They encompass several well-known principles ofSpecifically, we explore the suitability of defeasible language design.logic programming [12] for expressing the decision- Firstly, a language for specifying negotiationmaking process of negotiating agents, coupled with strategies needs to beformal, in the sense that itsstatecharts [13] for expressing their internal coordi- syntax and its semantics should be precisely defined.nation. We argue that defeasible logic is suitable for This ensures that the strategy specifications can beexpressing negotiation strategies, since it straight- interpreted unambiguously (both by machines andforwardly captures concepts such as preferences, humans) and that they are bothpredictable andhypotheses, arguments and counter-arguments. Onexplainable. In addition, a formal foundation is athe other hand, statecharts provide a comprehensive prerequisite for verification purposes.and concise approach to express the possible states Secondly, the language should beconceptual.and activities of a negotiating agent. This, following the well-knownConceptualization

M. Dumas et al. / Electronic Commerce Research and Applications 1 (2002) 193–207 195

Principle of [16], effectively means that it should strategies involving many issues (i.e. the executionallow its users to focus only and exclusively on performances should bescalable).aspects related to strategies, without having to deal Finally, the language that we aim for should bewith any aspects related to their realisation or sufficientlyexpressive, that is, it should be able toimplementation. Examples of conceptually irrelevant precisely capture a wide spectrum of strategies.aspects in the context that we consider are: physicaldata organisation and access, platform heterogeneity2 .2. An architecture for negotiating agents(e.g. message-passing formats), and book-keeping(e.g. message queue management). We view a negotiation process as a set of software

Thirdly, in order to ease the interpretation of agents which interact in order to reach an agreement.strategies and to facilitate their documentation, the Agents participating in a negotiation can interactlanguage should becomprehensible. Comprehen- directly or through a broker. In some situations, thesibility can be achieved by offering a graphical role of a party during the negotiation process isrepresentation, by ensuring that the formal and almost entirely carried out by the broker. This is theintuitive meanings are as much in line as possible, case for instance in some auction houses, where theand by offering structuring mechanisms (e.g. de- auction broker takes the place of the seller.composition). These structuring mechanisms often Following an abstract architecture for agents withlead tomodularity, which in our setting means that a memory presented in [17], each of the softwareslight modification to a strategy should concern only agents is composed of four modules: (i) a memorya specific part of its specification. Closely related to which contains the history of the past decisions andits comprehensibility, the language that we aim for, interactions of the agent, including its current inten-should besuitable, that is, it should offer concepts tions, (ii) a communication module responsible forclose to those required in negotiations. In particular, receiving and sending messages to the other agentsthe language should be able to address the following and interacting with the user, (iii) a reasoningaspects: coordination between concurrent negotiation module which encodes the decision-making part ofthreads, communication with external parties, partial, the agent, and (iv) a control module which coordi-incomplete and dynamic descriptions, hypothetical nates the other components. As a refinement to thisreasoning, defeasibility /belief revision, and ar- architecture, we choose to express the control mod-gumentation. ule as a statechart (see Section 2.3), the reasoning

As we are interested in the automation of the module as a defeasible logic program (see Sectionnegotiation process, the strategy description language 2.4), and the memory as a knowledge base of strictshould be executable, and its execution should and defeasible facts. The architecture can then beexhibit acceptable performances even for complex depicted as in Fig. 1.

Fig. 1. Architecture of a negotiating agent.


Conceptually, each time that a negotiating agent is plain automata, by considerably reducing the numbernotified of a change in the negotiation status, it of states and transitions required in a specification.updates the base facts stored in the knowledge base For these reasons, statecharts are widely used inaccordingly, and it activates the reasoning module. the area of reactive systems development, and areThe reasoning module reads these facts from the becoming a standard for intra-object coordinationknowledge base, attempts to deduce new facts and modeling, as they are part of the Unified Modelingrefute existing ones, and updates the derived facts Language (UML) [18]. In the sequel, we adoptstored in the knowledge base accordingly. Depend- UML’s syntax of statecharts, which is slightly differ-ing on the state of the knowledge base after this ent from the one described in [13].revision process, the control module determines Statecharts are finite state machines whose stateswhether it should ask the communication module to are optionally labeled by a name and a list of actions,submit a proposal or counter-proposal immediately, and whose arcs are optionally labeled by Event-or it should wait for some further event, or retract Condition-Action rules.from the negotiation. It is also through the communi- The occurrence of an event can fire a transition ifcation module that the control module communicates (i) the machine is in the source state of the transition,with the agent responsible for managing the user (ii) the type of the event occurrence matches theinterface (which is not shown in Fig. 1). This event description attached to the transition, and (iii)separation between the agent responsible for hand- the condition of the transition holds. An eventling the negotiation process, and the one responsible occurrence can be the reception of a signal, a changefor interacting with the user (e.g. for collecting the in the system’s clock, or a change in the truth valueparameters of the negotiation, or for displaying its of a condition. The event, condition, and action partsstatus), adds considerable flexibility to the architec- of a transition are all optional. A transition withoutture. In particular, these two agents can be located in an event is called atriggerless transition. Triggerlessdifferent machines, and the negotiating agent can transitions are enabled when the action(s) attached toeven be mobile. their source state is (are) completed. On the other

To summarise, a negotiation strategy is composed hand, transitions labeled by events can fire during theof a statechart, a set of ‘scripts’, a defeasible logic execution of the sequence of actions attached to theirprogram, a set of initial facts, and the addresses of source state. In this case, this execution is inter-the other parties involved in the negotiation. This rupted.strategy is executed by an agent shell, composed of a Acompound state is one whose action part isstatechart interpreter, a defeasible logic inference described itself as one or several statecharts. Com-engine, and a communication layer. Therefore, a pound states come in two flavours: OR and AND. Anstrategy can be seen as a plug-in component, which OR-state contains a single statechart, while an AND-can be dynamically loaded into an agent shell to state contains several statecharts which are intendedobtain a negotiating agent. to be executed concurrently. Each of these statech-

arts is called aconcurrent region. Concurrent regions2 .3. Expressing internal coordination: Statecharts are separated from each other by a dashed line.

Composition is recursive, that is, the substates of aWhen it comes to model control-flow, automata- compound state may themselves be decomposed

based notations are a natural choice, since they are either as OR-states or as AND-states.conceptual, formal, executable, comprehensive, and The statechart in Fig. 2 describes the controlsuitable for modeling concepts such as branching and module of an agent participating in three auctions.loops. Among the many automata-based notations The agent starts by contacting each of the auction-that can be found in the literature, statecharts [13] eers in parallel, asking for the current quote (see thehave proven to be suitable for designing complex three concurrent regions separated by dashed lines).systems, since they provide constructs for capturing As soon as a quote arrives, it is inserted in theconcurrency, they offer a good degree of modularity, knowledge base, and when the three quotes haveand they provide better comprehensiveness than arrived, the reasoning module is activated (see state


Fig. 2. Extract of the control module of an agent participating in several auctions.

‘Auction selection’), so as to determine whether a making aspects of negotiation strategies using abid should be submitted, and to which auction. If a language based on non-monotonic reasoning. Non-bid is submitted, then the agent waits for an answer, monotonic reasoning is a complex phenomenon withwhich can be one of two: either another participant many facets. Consequently, a plethora of non-mono-overbids, in which case the whole process has to be tonic logics have emerged in the past years. Un-restarted, or the bid wins the auction. fortunately, most of them have different and some-

times incompatible intuitions, they are computation-2 .4. Expressing flexible decision-making: ally intractable [20], and they have been used only indefeasible logic a few standard toy examples, whereas real-life

applications require low complexity and the ability toApplying a negotiation strategy in a particular handle more complicated cases.

context is an intensive decision-making process. In this paper, we advocate the use of defeasibleWhile most aspects of this decision-making process logic (DL) [12] to model negotiation strategies. Thiscould be fully captured in classical logic program- logic offers the advantages of non-monotonic reason-ming (which has a formal semantics and has proven ing for negotiation strategy specification (such as theto be a powerful tool for building decision-making ability to handle partial, incomplete and dynamicsystems), this would put a burden on the developers descriptions), while not suffering from the drawbacksof strategies, since logic programming is a generic mentioned above. The following are the majorparadigm and offers nothing specific to deal with the reasons supporting this choice:common characteristics of negotiation strategies suchas argumentation, hypothetical reasoning, partial, • A negotiation can be thought of as a dialogueincomplete and dynamic descriptions (see suitability between parties concerning the resolution of arequirement in Section 2.1). dispute. This suggests that argumentation based

It is well known that non-monotonic reasoning is reasoning formalisms are suitable to character-appropriate to model the above characteristics [19]. ise it. In Governatori and Maher [21], it wasAccordingly, we propose to express the decision- shown that DL can be characterised by an


argumentation semantics, thus the formal andA , . . . ,A ⇒ B, whereA , . . . ,A is a possibly1 n 1 n

semantics of defeasible logic is in line with the empty set of prerequisites andB is the conclusion ofargumentative nature of negotiations. the rule.

• Given the close connection between derivations Strict rules are rules in the classical sense: when-in DL and arguments, it follows that negotiation ever the premises of a rule are given, we are allowedstrategies expressed in DL are explainable. to apply the rule and get a conclusion. When the

• In contrast to many other non-monotonic logics, premises are indisputable (e.g. facts) then so is theDL is ‘skeptical’, meaning that it does not conclusion. An example of a strict rule is ‘every emusupport contradictory conclusions. Instead DL is a bird’. Written formally:seeks to resolve conflicts. In cases where there

emu(X) → bird(X)is some support for concludingA but alsosupport for concluding¬ A, DL does not con-

Defeasible rules are rules that can be defeated byclude any of them (thus the name ‘skeptical’). Ifcontrary evidence. An example of such a rule isthe support forA has priority over the support‘birds usually fly’; written formally:for ¬ A then A is concluded. It can be argued

that non-skeptical reasoning is inappropriate for bird(X) ⇒ fly(X)modeling decision-making processes such asnegotiations, since it is undesirable to deduce The idea is that if we know that something is a bird,both that a decision should be taken, and that it then we may conclude that it has the capacity ofshould not be taken. flying, unless there is other evidence suggesting that

• DL is representative of non-monotonic reason- it has not.ing formalisms: many variants of DL have been Defeaters are a special kind of rules. They areproposed and it has been shown that these used to prevent conclusions, but never to supportvariants are able to capture most of the different them. For example:intuitions of non-monotonic reasoning [22].

heavy(X)ß¬fly(X)Moreover some of these variants are equivalentto other non-monotonic formalisms [23]. This rule states that we have some reasons to believe

• DL integrates the concept of priorities between that heavy things may not fly; however our belief is arules, thereby supporting a direct way of model- weak one and we do not want to conclude thating preferences, without having to attach a something does not fly only because it is heavy.metrics to them, as in the case of approaches The superiority relation among rules is used tobased on utility functions [24]. define priorities among rules, that is, where one rule

• DL has a linear complexity, and existing im- may override the conclusion of another rule. Forplementations are able to deal with non trivial example, given the defeasible rules:theories consisting of over 100,000 rules [25],offering thus an executable and scalable system. r: bird(X) ⇒ fly(X)

A defeasible theory, i.e. a knowledge base in defeas- r9: emu(X) ⇒ ¬ fly(X)ible logic, consists of six different kinds of knowl-edge: facts, strict rules, defeasible rules, defeaters, a which contradict one another, no conclusive decisionsuperiority relations , and a specification of con- can be made about whether an emu can fly. But if weflicting literals. introduce a superiority relations with r9s r, then

Facts denote simple pieces of information that are we can indeed conclude that the emu does not fly.deemed to be true regardless of other knowledge In this paper, we assume that the superiorityitems. A typical fact is that Tweety is an emu: relation is acyclic.emu(Tweety). For each literalp we define the set ofp-Com-

Strict and defeasible rules are represented, respec-plementary literals #( p), that is, the set of literalstively, by expressions of the formA , . . . ,A ⇒ B that cannot hold whenp does. Let us consider an1 n


example: suppose we have the predicatesmarried context. These constraints set the basic boundaries ofand bachelor. Here, we define, for any constanta, the negotiating agent behaviour, and are used (for#(married(a))5 h¬married(a),bachelor(a)j. We example) to model decisions that must be sys-know that, under the usual interpretation of the tematically taken when a given condition holds. Hardpredicates they cannot be true at the same time for constraints and hard business rules are formalisedone and the same individual. We stipulate that the directly as strict rules.negation of a literal is always complementary to the Soft constraints (or soft business rules) on theliteral. other hand can be violated under particular circum-

We now give a short informal presentation of how stances (i.e. they have exceptions). They are used toconclusions are drawn in defeasible logic. A conclu- model the guidelines and user preferences that thesion P can be derived if there is a rule whose negotiating agent will consider after making sure thatconclusion isP, whose prerequisites (antecedent) are all the hard constraints and rules are met. A softeither already been proved or given in the case at constraint is formalized as a team of defeasible rules.hand (i.e. facts), and any stronger rule whose conclu- Specifically the soft constraint itself is first translatedsion is¬P has prerequisites that fail to be derived. In into a defeasible rule in this team, and each excep-other words, a conclusionP is derivable when: tion to the constraint is then encoded as a separate

defeasible rule, whose conclusion is the negation of• P is a fact; or the conclusion of the defeasible rule corresponding• There is an applicable strict or defeasible rule to the soft constraint. For example, if a soft con-

for P, and either straint C is formalised by the defeasible rule r1:— All the rules for ¬P are discarded or A , . . . ,A ⇒ B (meaning that ‘normally’ if1 n

— Every rule for ¬P is weaker than an A , . . . ,A hold, then so shouldB), and if we know1 n

applicable strict or defeasible rule for that the state of affairs D constitutes an exception toP. C, then D must be formalized as r2:D ⇒ ¬ B. Since

D is an exception to C, we have to specify that r2For a formal definition of derivability in defeasible has precedence over r1, i.e. r2s r1.logic and a discussion on some of its properties see In the third step, the developer should identifyfor example [12]. In what follows, we rather focus pairs ofincompatible litterals. Two litterals are saidon the application of defeasible logic to automated to be incompatible if they cannot both hold at thenegotiation. Specifically, we sketch a set of guide- same time, which essentially means that one of thelines that can be used to formalize a negotiation litterals implies the negation of the other. Havingstrategy in defeasible logic. First of all, the negotiat- identified conflicting litterals, and with the aid of aning agent developer needs to conduct an information inference tool, the developer can then detectconflict-analysis in order to identify an appropriate set of ing (defeasible) rules, i.e. rules such that the litteralspredicates to encode the negotiation strategy. These appearing in the conclusions are incompatible. As wepredicates must collectively capture the information have alluded to above, no conclusion can be drawncharacterising a given negotiation situation (e.g. from conflicting rules in defeasible logic, unlessnegotiation issues, user parameters, thresholds, limit these rules are prioritised. For each pair of conflict-values, histories of offers, etc.) as well as the ing defeasible rules, the developer must analyse whatconclusions that can be derived from a negotiation will happen when the conjunction of the antecedentssituation (e.g. the actions that may need to be of the rules holds, and must deduce a priorityundertaken at a given point during the negotiation). between these rules from this analysis. In some

Next, the developer needs to identify the con- cases, this analysis can be partially supported by anstraints over the negotiation, and the business rules automated tool. Indeed, several criteria for auto-governing the negotiation strategy. These constraints matically determining priorities among rules haveand business rules must then be classified as either been put forth, one of the most common being thehard or soft. Hard constraints (or hard business rules) specificity criterion. In a nutshell, a rule is moreare those that apply in any situation, regardless of the specific than another one, when it applies in all cases


where the other does. In other words, the set of derived predicateP, and update the knowledge baseprerequisites of the more general rule is a subset of accordingly.the set of prerequisites of the more specific rule. Insuch cases, it can be suggested to the developer togive a higher priority to the more specific rule. 3 . Case studiesHowever, the developer may decide to do theopposite, since specificity alone is not always an Our approach to validate our proposal has been toappropriate criterion for ranking rules. In addition, in use it in a number of case-studies involving a varietygeneral, two rules cannot be compared according to of negotiation situations. We have in particularthe specificity criterion, and thus, the developer must applied our approach to design strategies for botheither determine different ranking criteria or perform bilateral and multi-party negotiation, and even toa manual ranking. design agents capable of concurrently participating in

several alternative negotiations. In this section, wedetail two of the most representative case-studies that

2 .5. Glueing the control and the reasoningwe have addressed: one concerning an English

modulesauction, and the other one concerning a one-to-manybargaining scenario, where one buyer simultaneously

In the example presented in Fig. 2, we used anbargains with several potential sellers.

informal syntax for describing the conditions andactions labeling the transitions and states of the 3 .1. An English auction bidding agentstatechart. It is actually in these conditions andactions, that the interaction between the control

The English auction is perhaps one of the mostmodule and the other modules is expressed.

popular one-to-many negotiation mechanisms. In itsSpecifically, the conditions labeling the arcs of the

simplest form, it serves to select a buyer for an itemstate-charts are queries to the knowledge base, while

and to establish its price (multi-party single-issuethe actions fall within one of the following

negotiation). There are many variants of the Englishcategories:

auction (see [26] for a survey). The variant that iscurrently in use within the biggest online auction

• Updates to non-derived predicates stored in the houses (e.g. [27]) may be roughly described asknowledge base. follows. The seller starts by setting areservation

• Activation of the reasoning module: that is, price, which may or may not be announced to therequesting the reasoning module to compute the bidders. He also sets atiming constraint, which mayvalue for one or several derived predicates and be either expressed as a firm deadline, as a maximumrefresh the knowledge base accordingly. duration between two successive bids, or as both.

• Sending a message to either a negotiating party Potential buyers then issue increasingly higher bids.or to the user through the communication The increment between one bid and the next ismodule. constrained to be greater than a given threshold. The

auction stops when the timing constraint is violated,In the general case, these actions must be im- i.e. either the deadline is reached, or no bid isplemented using an external programming language. registered for longer than the established maximumHowever, many of them can be automatically gener- duration. The last bidder then buys the item at theated by a tool for building negotiating agents. For price of the last bid. If no bid is issued at or aboveinstance, for each non-derivable predicate ‘P’ ap- the reservation price, the item is not sold.pearing in the defeasible program, the tool could To illustrate how a bidder’s strategy is expressedgenerate the corresponding action ‘set P’ (e.g. using defeasible logic, we consider the following

]set quote, set current bid, etc.). In addition, the tool scenario. A user wishes to participate in the auction

] ] ]could provide implementations for actions such as of an item. (S)he doesn’t know exactly how much‘revise(P)’, which would compute a value of the the item is worth, but (s)he thinks that its value lies


somewhere within two boundsL andU. The user is The rules for deriving predicateshighest quotes and]

keen not to over-value the item, so (s)he decides to quotes above out of predicateprice quotes are all] ]

assume at the beginning of the auction that the item strict (i.e. not defeasible), and therefore we omitis worth L, and to eventually increase his valuation them in the sequel.whenever one of the following two situations occurs: The parameters and decision rules of the user’s(a) at least three bids above his /her current valuation strategy are modeled by the following constants andhave been registered, or (b) somebody has bid more predicates:than 20% of his /her current valuation. As soon asone of these conditions is met, the user will raise his • Constanttime threshold is the duration to the

]valuation by the minimum possible amount that deadline, below which the user estimates that heallows him/her to stay in the auction. However, (s)he should bid his /her valuation instead of justwill never value the item aboveU. As usual in the overbidding by the minimum increment.case of English auctions, the user will start by • Constantsignificant bidders is the number of

]bidding the reservation price (or the minimum pos- bidders that should bid above The user’s currentsible bid if the reservation price is not known), and valuation before (s)he considers raising it.(s)he will subsequently overbid the other particip- • Constant significant increment is the amount

]ants’ bids by the minimum increment, as long as the (expressed as a percentage), that another bidderresulting bid is less than his /her current valuation. should bid above the user’s current valuationHowever, if the auction’s deadline is too close, (s)he before (s)he considers raising it (in the workingwill bid his current valuation instead of just overbid- example this is 0.2).

1ding by the minimum increment. • Constantmax valuation is self-explanatory.]

Formally, the parameters, status, and history of the • Predicatessubmit bid(X) states that a bid of]

auction, are modeled through the following predi- amountX should be submitted.cates and constants: • Predicatevaluation(X) gives the current valua-

tion while pre valuation(X) gives the valuation]• Constantmin increment denotes the minimum that was valid at the end of the previous]

amount by which the bidders are allowed to activation of the reasoning module.overbid. • Predicatemy bid(X) gives the amount of the last

]• Constant initial bid denotes the minimum accepted bid issued by the bidder. At the]amount of the first acceptable bid. beginning of the auctionmy bid(0) holds.

]• Predicate time remaining(T ) gives the time]

remaining before the end of the auction. The rules modeling the strategy are:• Predicatehighest quote(N) provides the current

] r1: my bid(X),highest quote(Y),valuation(Z),highest bid. ] ]X ,Y,Y 1min increment , Z,• Predicatequotes above(X,N) holds if N bids ]]

above amountX have been registered. time remaining(T ),T . time threshold] ]

⇒ submit bid(Y 1min increment)] ]The last two predicates (highest quote and

]r2: my bid(X),highest quote(Y),valuation(Z),quotes above) provide aggregate views over the ] ]]

X ,Y,Y 1min increment , Z,history of the negotiation process as seen by the]

agent. This history is captured by a predicatehis- time remaining(T ),T # time threshold] ]

tory(L), whereL is a list of pairsktime, proposall. In ⇒ submit bid(Z)]the case of an auction, the proposals are the price

r3: pre valuation(X) ⇒ valuation(X)quotes received by the agent from the auction broker. ]

r4: pre valuation(X),quotes above(X,N),1 ] ]The reasoning module that we develop here can be easily adapted N $ significant bidders,highest quote(Y)to capture strategies where the increment between one bid and the ] ]

⇒ valuation(Y 1min increment)next is gradually increased as the deadline approaches. ]


r5: pre valuation(X),highest quote(Y), knowledge base contains the fact] ]Y . (11 significant increment)3X ≠ submit bid(initial bid). Accordingly, the agent con-] ] ]

tacts the auctioneer to submit a bid (using action⇒ valuation(Y 1min increment)]

send bid). If the bid is accepted, the agent receives a]r6: Y .max valuationß¬valuation(Y) message which, when processed by the communica-]

tion layer, generates the eventbid accepted. When a]Rules r4 and r5 have precedence over r3.

bid is accepted, the agent introduces a fact of theThe sets of complementary literals state that thereform my bid(X) into the knowledge base and waits

]can only be one amount to bid, and one newuntil a new quote is inserted. If on the other hand, avaluation, i.e.submitted bid is rejected, this means that anotherparticipant bid the same or a higher amount before• #(submit bid(x))5 h¬ submit bid(y)uy ± xj

] ] the submission was processed, and therefore, the• #(new valuation(x))5 h¬new valuation(y)] ] agent receives a quote with this amount instead of anuy ± xj

acceptance message. Quotes are handled by therightmost region of the statechart, which inserts them

Rules r1 and r2 model the bidding strategy: Rule r1into the knowledge base, and generates a

states that if there is enough time remaining and thequote inserted event after each insertion. These

]agent’s current bid is not the highest one, it shouldevents are consumed by the left concurrent region.

be increased by the minimum increment, providedWhen the inference engine cannot deduce a fact of

that the current valuation allows so. Rule r2 statesthe form ≠ submit bid(M), the control module takes

]that if the deadline is close and the bidder does notthe transition labeled ‘else’ in Fig. 3, which leads to

hold the item, a bid of the amount of the currentstate ‘Wait overbid’. From then on, it waits for new

valuation should be submitted immediately. Rules r3quotes and when it receives one, it updates the

through r6 model the evolution of the valuation: Ruleknowledge base and invokes the inference engine

r4 and r5 model the two conditions under which theagain.

valuation should be raised, while rule r6 is a defeaterAs stated in Section 2.5, the conditions labeling

modeling the fact that the bidder is under nothe transitions of the statechart are queries to the

circumstances willing to value the item above aknowledge base, while the actions correspond to

given amount. The use of this defeater provides aupdates, as well as invocations of the communication

strong modularity to the defeasible program. If forand the reasoning module. Some of these actions,

instance the user wanted to modify the abovesuch as ‘revise’, ‘set previous valuation’ and

] ]strategy with a statement of the form‘ raise the‘set my bid’ are predefined or can be automatically

] ]valuation if the reservation price has not been metgenerated from the profiles of the corresponding

and the highest bid is above my current valuation’ ,predicates. Others such as ‘notify win’ and

]then (s)he just has to extend the above defeasible‘notify loss’ have to be coded in an external pro-

]logic program with the following rule:gramming language.

r7: reservation not met,valuation(X),] ] 3 .2. Bargaining with multiple partieshighest quote(Y),Y .X

]⇒ valuation(Y 1min increment)

] In a bargaining setting, the negotiation processr7s r3

begins with an initial offer formulated by one of thewithout having to worry whether the reservation parties, and proceeds with an alternate exchange ofprice is greater than his /her maximum valuation or offers, which stops when either an agreement isnot. reached, or one of the parties decides to terminate

The control module of the bidding agent is the negotiation without an agreement. In manydescribed as a statechart in Fig. 3. The left region of realistic scenarios, a party is not involved in a singlethe statechart is responsible for invoking the infer- bargaining process at a time, but rather, severalence engine. At the beginning of the process, the bargainings over the same issue take place concur-


Fig. 3. Specification of the control module of a bidding agent in an English auction.

rently. This is the case for an individual who tions where an agent negotiates with several otherscontacts several merchants in search of the best concurrently. Indeed, if offers were binding, an agentterms for buying a product. Under this perspective, sending an offer would have to wait for the offer tothe decision to terminate a given negotiation thread be accepted or rejected before sending any offer to(i.e. a negotiation with a given party), and even the another party, and the concurrency would thus bestrategy for formulating a counter-offer, is dependent limited.on the progress and outcomes of other negotiations We consider an agent responsible for negotiating athreads. A negotiating agent for this kind of price with several potential sellers on behalf of ascenarios should therefore have a global view of all buyer. The control module of this agent is modeledthe negotiations in which the party that it represents as a statechart in Fig. 4. Offers sent by the sellers areis involved. arranged in a queue. The left concurrent region of

In this section, we focus on single-issue bargain- the statechart describes how the offers are unqueueding with non-binding offers. By ‘non-binding’ we and evaluated. The outcome of the evaluation of anmean that when a partyP1 sends an offer to another offer can be one of three actions: accept the offer,partyP2, if P2 wishes to accept this offer, it needs to propose a counter-offer, or terminate the negotiationask P1 for confirmation. It is not untilP1 confirms with the corresponding party. If an offer is accepted,its offer that that the negotiation is terminated with the negotiating agent asks the other party to confirman agreement. IfP1 refuses to confirm its offer, then the agreement, and upon receiving confirmation, itit must either formulate a new offer or terminate the terminates the whole negotiation process (i.e. all thenegotiation. This protocol is appropriate for situa- threads). If on the other hand a message of confirma-


Fig. 4. Specification of the control module of a multi-party bargaining agent.

tion refusal is received, or the confirmation message the other for evaluating an offer. The rules foris not replied after an agreed delay, an occurrence of selecting an offer are simple (pick the offer with theevent ‘no confirmation(P,F )’ is generated, and the lowest price among those which have not yet been

]agent continues to negotiate with the other parties. evaluated), and we therefore omit their description.

The rightmost region of the statechart is respon- The predicates for evaluating a given offer are:sible for receiving offers and termination messagesfrom the sellers. When there are no more potential • Offer(P,X): The current offer of partyP is X (wesellers remaining, the negotiation process is termi- assume thatX is an integer).nated with a failure. Similarly, when a party is • Previous offer(P,X): The previous offer of party

]willing to accept the last counter-offer that has been P wasX. If P has not made any previous offer,sent to it (i.e. a confirmation for a counter-offer is then the defeasible logic inference engine willrequested), a confirmation message is sent and the deduce¬previous offer(P,X).

]whole negotiation process is terminated. • Counter offer(P,X): The reasoning module sug-

]Notice that it is not the buyer but the sellers who gests to reply toP’s most recent offer with

are responsible for generating the initial offers. counter-offerX.Accordingly, we will use the term ‘offer’ to desig- • Previous counter offer(P,X): The counter-offer

] ]nate the prices proposed by the sellers, and the term suggested by the reasoning module in response‘counter-offer’ to refer to the prices proposed by the ofP’s second most recent offer wasX.buyer. • Accept( p): The inference engine suggests to

The reasoning module of the negotiating agent is acceptP’s most recent offer.composed of two separate defeasible logic programs: • Terminate( p): The inference engine suggests toone for selecting the next offer to be evaluated, and stop negotiating withP.


Finally, the rules involving these predicates are: enough to deal with several kinds of auctions (e.g.English, Dutch, double, etc.) through a common set

r1: offer(P,Y),¬previous offer(P,Z),Y . good offer of primitives. The AuctionBot has recently been used] ]⇒ counter offer(P,good offer) to host a trading agent competition [6], as has] ]

another similar platform called FishMarket [7]. Un-If this is the first offer fromP and that it is not good like our work, neither FishMarket nor the Auction-enough, ask for a good price. Bot, address the issue of specifying bidding agent

strategies.r2: offer(P,Y),previous offer(P,Z),Y $ Z] Many efforts in the area of automated negotiation⇒ terminate(Z)

have focused on applying game theory techniques,either to design a protocol that encourages theIf P has not improved his offer with respect to theparticipants to adopt a desirable strategy, or to designprevious one, stop negotiating.an optimal strategy for a given protocol [2,3].Although this approach yields interesting resultsr3: offer(P,Y),previous offer(P,Z),Y , Z,

]under simplifying assumptions (e.g. known valua-previous counter offer(P,X),best offer(W )

] ] ] tions, risk-neutral attitudes, computationally un-⇒ counter offer(P,min(X 2 increment,W ))] bounded agents), it is difficult or impossible to apply

If P has improved his offer with respect to the them in some realistic situations [5]. For this reason,previous one, then concede a small amount with [30] advocates the use of heuristic-based approachesrespect to the previous counter-offer. However, do in cases where game theoretic techniques are notnot counter-propose a price below the current best applicable. Our work is complementary to the aboveoffer. ones, since we do not address the issue of designing

strategies, but rather that of specifying them in anr4: few parties,offer(P,Y),best offer(Z),Y #Z,

] ] executable form.Y # acceptable price ⇒ accept(P,Y) Garcia et al. [31] suggests to use a ‘variant’ of]

defeasible logic to express strategies for agentsIf there are few parties remaining and that the offertrading over stock markets. The defeasible logicof P is acceptable and it is the the best one that hasconsidered in this reference does not support anbeen received, accept it. A similar rule could be usedexplicit ranking of the rules within a theory, butto take into account the situation where the deadlinerather derives this ranking through a specificityfor reaching an agreement is close.criteria over arguments. Roughly speaking, an argu-ment is more specific than (and therefore can defeat)r5: offer(P,Y),Y # good price ⇒ accept(P,Y)

] another argument, if it takes into account moreIf somebody offers a good price, accept it. information. In addition to the fact that this approach

Rules r4 and r5 both have precedence over r1, r2 allows tie-breaks between defeasible arguments, itand r3. may sometimes lead to counter-intuitive situations,

since the semantics given by a user to the concept of‘more information’, may potentially not be in line

4 . Related work with that given by the defeasible logic’s inferencemethod. Another important difference between the

The Michigan AuctionBot [28,29] is an auction above proposal and ours, is that the control modulemanagement server supporting the creation, location is expressed through Prolog rules. We believe thatand enactment of different kinds of auctions. Users event-driven formalisms such as statecharts, arecan manually interact with the system through an more appropriate for this.HTML-based interface, or alternatively, they can Grosof et al. [32] use Courteous Logic Program-develop their own arbitrarily complex bidding ming (CLP) to express knowledge about user prefer-agents, and connect them to the auction manager ences, constraints, and negotiation structures. Thethrough a TCP-level API. This API is generic authors do not address the issue of specifying


bidding strategies, but rather that of determining the (defeasible) rules to specify the decision-makingaspects of negotiation strategies. It is conceivableset of auctions and other negotiations that need to behowever to use rules not only for specifying negotia-undertaken in order to transform a contract templatetion strategies, but also for expressing the offers andinto an executable contract. Interestingly, Defeasiblecounter-offers exchanged between agents during aLogic (DL) is more expressive than CLP, in thenegotiation. Allowing agents to exchange rules,sense that it fully supports stratified theories [23].instead of just exchanging simple communicationHence, the question remains open whether it isperformatives, significantly increases the flexibilitypossible to express ‘useful’ contract templates in DLof a negotiation protocol. Indeed, agents can thenthat are not expressible in CLP.dynamically add, remove, or modify issues. TheyIn this paper, we did not address the issue ofcan also express entire spaces of acceptable deals ininter-agent message exchange. For some negotiationa single message, instead of expressing only oneprotocols such as the English and the Dutch auctions,acceptable deal per message. This idea, which issome standardisation proposals are being developedsuggested in [32,37], is certainly worth furtherby the FIPA organisation [33]. Also, inter-agentinvestigation.communication protocols such as [34] could be used

Another avenue for future work is the integrationfor this purpose.of defeasible logic, as a formalism for qualitativelyexpressing preferences, with a quantitative formalismsuch as Multi-Attribute Utility Theory (MAUT).5 . ConclusionIndeed, the application of MAUT to capture prefer-ences and trade-offs over multiple issues in theWe have proposed a pragmatic approach tocontext of both manual and automated negotiations,negotiating agents development, which seamlesslyhas been thoroughly studied [24,30,38]. MAUT-combines an imperative formalism (statecharts) withbased approaches to strategy specification are espe-a declarative one (defeasible logic). The choice ofcially suitable in situations where it is intuitive tothese two formalisms has been justified against a setattach metrics to both the negotiation issues and theof desirable criteria for negotiation strategy spe-user preferences. In contrast, the logic-based ap-cification languages, and their suitability has beenproach presented in this paper is suitable when therevalidated through concrete examples of non-trivialis no intuitive way of defining such metrics, butnegotiation strategies. In particular, we have showninstead the user has in mind a set of prioritisedthat this approach is applicable for developing agentsguidelines to find acceptable deals. The marriage ofcapable of participating in multiple concurrentthese two types of formalisms (quantitative andnegotiations.qualitative) can thus lead to a powerful approach forAll the defeasible logic programs appearing in thespecifying negotiation strategies.paper have been tested using a defeasible logic

inference engine [35]. Currently, the translation ofthe statechart into an executable program is carried

R eferencesout manually. However, it is clear that this processcould be automated, and as a matter of fact, there

[1] P. Maes, R. Guttman, A. Moukas, Agents that buy and sell,exist several commercial tools for generating codeCommunications of the ACM 42 (3) (1999) 81–91.from a statechart (e.g. Statemate Magnum [36]).

[2] J.S. Rosenschein, G. Zlotkin, Rules of Encounter: DesigningAlternatively, an interesting approach would be to Conventions for Automated Negotiation Among Computers,develop an interpreter of statecharts, which com- MIT Press, Readings, MA, 1994.bined with a defeasible logic inference engine, and [3] T. Sandholm, Distributed rational decision making, in: G.

Weiss (Ed.), Multiagent Systems: A Modern Introduction toan appropriate inter-agent communication library,Distributed Artificial Intelligence, MIT Press, Cambridge,could be used to build an agent shell capable ofMA, 1999.

dynamically loading and executing negotiation stra- [4] G. Weiss (Ed.), Multiagent Systems: A Modern Introductiontegies expressed in our framework. to Distributed Artificial Intelligence, MIT Press, Cambridge,

In this paper, we have advocated the use of MA, 1999.


[5] N.R. Jennings, P. Faratin, A.R. Lomuscio, S. Parsons, C. [22] G. Antoniou, D. Billington, G. Governatori, M.J. Maher, ASierra, M. Wooldridge, Automated negotiation: Prospects, flexible framework for defeasible logics, in: Proceedings ofmethods and challenges, Journal of Group Decision and the American National Conference on Artificial IntelligenceNegotiation 10 (2) (2001) 199–215. (AAAI), AAAI /MIT Press, Canbridge, MA, 2000, pp. 405–

[6] B. Strother, TAC: A Trading Agent Competition, ACM 410.SIGeCom Exchanges 1 (1) (2000) 624–626. [23] G. Antoniou, M.J. Maher, D. Billington, Defeasible logic

[7] AMECIII trading agents’ tournament, IIIA, ISOCO and UPC versus logic programming without negation as failure, Jour-(organizers), http: / /www.iiia.csic.es/Projects /fishmarket / nal of Logic Programming 42 (1) (2000) 47–57.agents2000,June 2000. [24] H. Raiffa, The Art and Science of Negotiation, Harvard

´[8] E. Gimenez-Funes, L. Godo, J.A. Rodriguez-Aguilar, P. University Press, Cambridge, MA, 1982.´Garcia, Designing bidding strategies for trading agents in [25] M.J. Maher, A. Rock, G. Antoniou, D. Billington, T. Miller,

electronic auctions, in: Proceedings of the 3rd International Efficient defeasible reasoning systems, International JournalConference on Multi-Agent Systems (ICMAS), Paris, on Artificial Intelligence Tools 10 (4) (2001) 483–501.France, July, 1998. [26] D. Lucking-Reiley, Auctions on the Internet: What’s being

[9] M. Dumas, L. Aldred, G. Governatori, A. ter Hofstede, N. auctioned, and how?, Journal of Industrial Economics 48 (3)Russell, Probabilistic automated bidding in alternative auc- (2000) 227–252.tions, in: Proceedings of the 11th International Conference [27] eBay, Home Page,http: / /www.ebay.comon the World Wide Web (WWW), Honolulu, HI, USA, May, [28] Michigan Internet AuctionBot, University of Michigan Arti-ACM Press, 2002. ficial Intelligence Laboratory,http: / /auction.eecs.umich.edu

[10] A. Chavez, D. Dreilinger, R. Guttman, P. Maes, A real-life [29] P.R. Wurman, M.P. Wellman, W.E. Walsh, The Michiganexperiment in creating an agent marketplace, in: Proceedings Internet AuctionBot: A configurable auction server forof the 2nd International Conference on The Practical Appli- human and software agents, in: Proceedings of the 2ndcations of Agents and Multi-Agent Technology (PAAM), International Conference on Autonomous Agents, ACMLondon, UK, 1997. Press, 1998.

[11] Reticular Systems Inc., Agent construction tools.http: / [30] P. Faratin, C. Sierra, N.R. Jennings, Negotiation decision/www.agentbuilder.com/AgentTools functions for autonomous agents, International Journal of

[12] D. Billington, Defeasible logic is stable, Journal of Logic and Robotics and Autonomous Systems 24 (3–4) (1998) 159–Computation 3 (1993) 370–400. 182.

[13] D. Harel, A. Naamad, TheSTATEMATE semantics of statech- [31] A. Garcia, D. Gollapally, P. Tarau, G. Simari, Deliberativearts, ACM Transactions on Software Engineering and Meth- stock market agents using Jinni and defeasible logic pro-odology 5 (4) (1996) 293–333. gramming, in: Proceedings of the ECAI Workshop on

[14] G. Governatori, A. ter Hofstede, P. Oaks, Defeasible logics Engineering Societies in the Agents’ World, Berlin, Ger-for automated negotiation, in: Proceedings of the CollECTeR many, August, Springer, Berlin, 2000.Conference on Electronic Commerce, Brisbane, Australia, [32] B.N. Grosof, D.M. Reeves, M.P. Wellman, AutomatedDecember, 2000. negotiation from declarative contract descriptions, in:

[15] A.H.M. ter Hofstede. Information Modelling in Data Inten- Proceedings of the International Conference on Autonomoussive Domains. PhD thesis, University of Nijmegen, Nij- Agents, Montreal, Canada, May, ACM Press, 2001, pp.megen, The Netherlands, 1993. 51–58.

[16] J.J. van Griethuysen (Ed.), Concepts and Terminology for [33] FIPA, Foundation for Intelligent Physical Agents, Interactionthe Conceptual Schema and the Information Base, ANSI, Protocols Specification Repository,http: / /www.fipa.org/ re-New York, 1982, ISO/TC97/SC5/WG3-N695. pository / ips.html

[17] M. Wooldridge, Intelligent agents, in: G. Weiss (Ed.), Mul- [34] KQML, University of Maryland Baltimore County,http: /tiagent Systems: A Modern Introduction to Distributed /www.cs.umbc.edu/kqmlArtificial Intelligence, MIT Press, Cambridge, MA, 1999. [35] D. Nute et al., Defeasible Logic Implementation, 2001,

[18] J. Rumbaugh, I. Jacobson, G. Booch, The Unified Modeling Accessed fromftp: / / ftp.ai.uga.edu/pub/prologon 14 March.Language Reference Manual, Addison-Wesley, Reading, [36] Logix Inc., Statemate Magnum.http: / /www.ilogix.comMA, 1999. [37] M.J. Wooldridge, S. Parsons, On the use of logic in negotia-

[19] G. Antoniou, Nonmonotonic Reasoning, MIT Press, Cam- tion, in: Proceedings of the Workshop on Agent Communica-bridge, MA, 1997. tion Languages, Barcelona, Spain, May, 2000, Accessed

[20] M. Cadoli, M. Schaerf, A survey of complexity results for fromhttp: / /www.csc.liv.ac.uk/sp/publications/conferences/nonmonotonic logics, Journal of Logic Programming 17 acl00.htmlon 18 July 2002.(1993) 127–160. [38] M. Barbuceanu, W.-K. Lo, A multi-attribute utility theoretic

[21] G. Governatori, M.J. Maher, An argumentation-theoretic negotiation architecture for electronic commerce, in:characterization of defeasible logic, in: W. Horn (Ed.), ECAI Proceedings of the International Conference on Autonomous2000. Proceedings of the 14th European Conference on Agents, ACM Press, Barcelona, Spain, 2000, pp. 239–246.Artificial Intelligence, Amsterdam, IOS Press, 2000.

http://www.iiia.csic.es/Projects/fishmarket/agents2000










http://www.ebay.com

http://www.ebay.com

http://www.ebay.com

http://www.ebay.com

http://auction.eecs.umich.edu




http://www.agentbuilder.com/AgentTools





http://www.fipa.org/repository/ips.html









http://www.cs.umbc.edu/kqml






ftp://ftp.ai.uga.edu/pub/prolog








http://www.ilogix.com




http://www.csc.liv.ac.uk/sp/publications/conferences/acl00.html












a formal approach to negotiating agents development

Documents