scispace - formally typeset
Search or ask a question
Book ChapterDOI

A software framework for automated negotiation

TL;DR: This chapter proposes an alternative approach, allowing all of a mechanism to be formal and explicit, and presents a taxonomy of declarative rules which can be used to capture a wide variety of negotiation mechanisms in a principled and well-structured way.
Abstract: If agents are to negotiate automatically with one another they must share a negotiation mechanism, specifying what possible actions each party can take at any given time, when negotiation terminates, and what is the structure of the resulting agreements. Current standardization activities such as FIPA [2] and WS-Agreement [3] represent this as a negotiation protocol specifying the flow of messages. However, they omit other aspects of the rules of negotiation (such as obliging a participant to improve on a previous offer), requiring these to be represented implicitly in an agent’s design, potentially resulting incompatibility, maintenance and re-usability problems. In this chapter, we propose an alternative approach, allowing all of a mechanism to be formal and explicit. We present (i) a taxonomy of declarative rules which can be used to capture a wide variety of negotiation mechanisms in a principled and well-structured way; (ii) a simple interaction protocol, which is able to support any mechanism which can be captured using the declarative rules; (iii) a software framework for negotiation that allows agents to effectively participate in negotiations defined using our rule taxonomy and protocol and (iv) a language for expressing aspects of the negotiation based on OWL-Lite [4]. We provide examples of some of the mechanisms that the framework can support.

Summary (5 min read)

1 Introduction

  • Recently there has been much interest in the role of dynamic negotiation in electronic business transactions.
  • In particular, the authors are concerned with the definition of interaction protocols underpinning a mechanism, rather than the emerging properties of the mechanism itself (for an example of the latter, compare [5]).
  • The FIPA protocol for an English auction, described informally above, is shown in [8].
  • To demonstrate the validity of their approach, in this chapter the authors also describe a software framework for automated negotiation that allows agents to effectively participate in negotiations defined using their rule taxonomy and protocol.
  • A more advanced agent would be able to automatically modify their behaviour as necessary, provided the changes to the mechanism were not too great.

2 The Generic Negotiation Framework

  • The authors present an abstraction of the negotiation process, developed from the analysis of many different negotiations, both automated and human.
  • From this, the authors develop a general protocol for negotiation.

2.2 Taxonomy of Rules for Negotiation

  • So far the authors have been talking about negotiation rules in a very generic fashion.
  • By examining the flexibility points of the abstract negotiation process described in the previous section, for a more complete analysis see [14] the authors identified the following categories of negotiation rules:.

Rules for Protocol Enforcement

  • Determines when a participant may post a proposal, also known as Posting Rule.
  • Specifies, given a set of existing proposals, what new proposals may be posted, also known as Improvement Rule.
  • Specifies if and when proposals can be withdrawn, and policies over the expiration time of proposals, also known as Withdrawal Rule.

Rules for Updating Status and Informing Participants

  • Specifies how the parameters of the negotiation change on occurrence of certain events, also known as Update Rules.
  • Specifies which participants can view a given proposal, also known as Visibility Rule.
  • Specifies if and how the information updater notifies the participants that a proposal has been submitted or an agreement has been made - either by transmitting the proposal unchanged or by transmitting a summary of the situation, also known as Display Rule.

Admission Phase

  • The authors begin by describing the admission phase.
  • The protocol requires the participant requesting admission to send an ACL.
  • The payload of the message may contain credentials of the participant.
  • FIPA propose interaction protocol, represented in figure 1 [8].

Proposal Submission Phase

  • After admission, the participants submit proposals by posting them to the negotiation locale.
  • Each time a participant submits a proposal the negotiation host checks that it is syntactically well formed and it is a more constrained version of the negotiation template.
  • The submitter is notified through an ACL.
  • Agents submitting proposals may also withdraw proposals if the rules of negotiation allow them to.
  • CANCEL message where the communicative act that is being canceled is the previous instance of the proposal (all this is done according to the FIPA cancel meta-protocol [8].

Agreement Formation Phase

  • An agreement formation process can be triggered at any time during negotiation, according to the agreement formation rules.
  • The negotiation host then looks at the current set of proposals to determine whether agreements can be made.
  • If this is the case, agreement formation rules determine exactly which proposals are matched and the final instantiated agreement that will be used.
  • Earlier posted offers may take priority over later ones.
  • Having defined the general protocol for negotiation (for a more complete specification and graphical representation, see [14]), the authors now show how it can be specialized in a variety of different ways.

3 Implementation of the Software Framework

  • Each sub-agent is responsible for the enforcement of one of the categories of rules described in section 2.2: Gatekeeper , Proposal Validator, Protocol Enforcer, Information Updater (updating status and informing participants), Negotiation Terminator (lifecycle of negotiation) and Agreement Maker.
  • The main abstractions in Jade are agents and behaviours (section 3.1).
  • The natural way of designing the negotiation host agents is as a rule engine.
  • To do this the authors use the Java Expert System Shell (Jess).
  • Proposals are also stored on the blackboard, provided they satisfy the negotiation template (section 3.3).

3.1 Agents and Behaviors

  • The Negotiation Host initializes the blackboard and creates the sub-ordinate agents.
  • When certain events occur (e.g. a new message or a change on the blackboard) they evaluate their rules and take the associated actions.
  • REQUEST message from the Negotiation Host containing information on participant identity and credentials, it evaluates the admission rules to decide whether the participant should be admitted to negotiation.
  • The submitter is informed through an ACL.
  • The Protocol Enforcer also processes withdrawal requests (ACL.

3.2 Assertions on the Blackboard

  • The authors now give details of the knowledge base used by the agents and then give details of the negotiation proposal language and negotiation rule language which make use of this.
  • This knowledge base is stored in the negotiation locale and is accessible by the negotiation host and its sub-agents.
  • All examples are given as Jess assertions and rules.

Facts About the Negotiation

  • Other parameters of the negotiation are asserted in the form (negotiation (id Negotiation-Id) (negotiation-parameter Value)).
  • Parameters associated with an English auction can be specified in the following way: (negotiation (id auction-37) (seller-proposal Alice-37) (bid-increment 5) (termination-window 30min) (currently-highest-bid 0)).
  • This states that auction-37 is selling a good described in proposal Alice-37 (See section 3.3), with an auction bid increment of 5.
  • The first four fields will remain fixed, while the fifth will be updated regularly.

Facts About Participants

  • When a participant is admitted, the gatekeeper asserts relevant facts in the knowledge base.
  • The participant is assigned an ID, and associated with a negotiation.
  • Other parameters of the participants are asserted in the format: (participant (id Participant-Id) (negotiation-id Negotiation-Id) (participant-attribute-name, Value)).
  • Based on a participant s credentials, the gatekeeper may assign them a credit limit: (participant (id Bob) (negotiation-id auction37) (creditLimit 10000)).

Facts About Proposal Status

  • Facts are asserted which specify the current status of proposals on the blackboard.
  • When a proposal is first received, its submission time is asserted by the Gatekeeper as: (submission-time 01/10/01:18:37 (proposal-id Proposal-Id)).
  • When the proposal validator has checked a proposal, it asserts: (valid-proposal (proposal-id Proposal-Id)).
  • In a negotiation where new proposals can supersede old ones (such as an English auction), the Information Updater will assert facts specifying which proposals are currently active (and retract this if the proposal is superseded).

3.3 Negotiation Proposals and Templates

  • The negotiation template and proposals are expressed as OWL-Lite descriptions [4].
  • For simplicity of exposition, here and in the following examples the authors will adopt a modified description logics notation [21] to express the proposals and the templates which is equivalent to the RDF OWL-Lite syntax [4].
  • XML Schema classes are not described but it should be clear by their names what they actually mean.
  • For brevity reasons, the authors will not exhaustively state all the description, but it should be quite intuitive to the reader what those concepts mean.
  • The Car class is a subclass of Product and must have at most one Model and Make.

Model = {Punto, TT, S80} Make = {Ford, Audi, Volvo}

  • A negotiation host wishing to conduct auctions of cars could define the template as: Template1 = Template ∩ Sale ∩ ∀item.
  • This states that Alice who is described as a participant in the participant ontology (see [19]) wishes to sell a Fiat Punto for at least £3000 with delivery date after Dec, 1st 2004.
  • When an agreement is formed, it can be verified a posteriori that the agreement subsumes the proposals that were used to form it and therefore the original negotiation template.
  • A description logics reasoner can check whether two concepts subsume each other [22].

3.4 Negotiation Rules

  • Subsidiary agents have standard rule templates, where the rule asserts information in their private fact base.
  • The agent responds to this information, executing appropriate actions and sending messages according to the General Negotiation Protocol.
  • The visibility rules have a similar format, and act as filters on new proposals.

4 Sample Mechanisms

  • The authors present a few examples of market mechanisms that the negotiation framework can support.
  • For each of the mechanisms the authors give a flavor of the rules that need to be specified and the negotiation template and the negotiation proposals that participants may exchange.

4.1 Single Item English Auction

  • Assume a Negotiation Host has advertised an agreement template as per section 3.3, and has been contacted by Alice to sell her Fiat Punto via auction.
  • It generates an associated agreement template, which is a specialized version of the one in 3.3, with the automobile slot instantiated with details of her Fiat Punto.
  • The price field of the buyer s proposal must be a certain increment above the value of all previously posted buyer proposals.

4.2 The Continuous Double Auction

  • A many-to-many Continuous Double Auction can be implemented in their framework by straightforward modification of the rules above.
  • The only substantial change is in the agreement formation rule.
  • Highest bids are matched with lowest offers, with the agreement at the midpoint.

4.3 Simple Shop Front

  • The framework can also model one-to-one negotiation such as a simple shop front.
  • Before negotiation begins, the shopkeeper decides the admission policy, negotiation template, and negotiation and agreement formation rules.
  • A seller may withdraw proposals at any time so long as they have not been matched yet with buyer s proposals.
  • The car dealer adopts standard shop front agreement formation rule: [Agreement formation rule].
  • If all proposals for a given good are accepted, and the car dealer still has more in stock, it resubmits identical proposals.

4.4 Multi-party Contracts

  • The examples given so far addressed the formation of two-party contracts, whatever the number of participants.
  • Secondly, visibility rules enforce that participants that have been admitted to play a certain role have a restricted view over other participant s proposals.
  • As an example, imagine that a multi-party agreement is sought between a building contractor and other participants to fulfill the role of a carpenter, builder, and electri4 However, they are similar enough to the ones in the two previous examples that the attentive reader will not have problems deriving them.
  • Participants are admitted to the negotiation bidding to undertake the roles that they specialize for.

6 Conclusions

  • The authors have discussed the shortcomings of the representation of negotiation mechanisms in standardization activities such as FIPA [2] and the Global Grid Forum s (GGF) WS-Agreement [3].
  • Specifically, the authors have shown that the protocol approach adopted by them and many others results in only part of a mechanism being explicitly formalised and standardised, which can result in significant drawbacks from a software engineering perspective.
  • Alternatively, the authors propose a modular approach to negotiation mechanisms: a generalized interaction protocol which can be specialised with declarative rules.
  • The authors provide a taxonomy of such rules and a software framework that implements this approach and give examples of rules for various negotiation mechanisms.

Did you find this useful? Give us your feedback

Content maybe subject to copyright    Report

213
R. Choren et al. (Eds.): SELMAS 2004, LNCS 3390, pp. 213–235, 2005.
© Springer-Verlag Berlin Heidelberg 2005
A Software Framework for Automated Negotiation
*
Claudio Bartolini
1
, Chris Preist
2
, and Nicholas R. Jennings
3
1
HP Laboratories. Page Mill Rd., Palo Alto, CA 94304, USA
claudio.bartolini@hp.com
2
HP Laboratories. Filton Road Store Gifford Bristol BS34 8QZ, UK
chris.priest@hp.com
3
University of Southampton. Southampton SO17 1BJ, UK
nrj@ecs.soton.ac.uk
Abstract. If agents are to negotiate automatically with one another they must
share a negotiation mechanism, specifying what possible actions each party can
take at any given time, when negotiation terminates, and what is the structure of
the resulting agreements. Current standardization activities such as FIPA [2]
and WS-Agreement [3] represent this as a negotiation protocol specifying the
flow of messages. However, they omit other aspects of the rules of negotiation
(such as obliging a participant to improve on a previous offer), requiring these
to be represented implicitly in an agent’s design, potentially resulting incom-
patibility, maintenance and re-usability problems. In this chapter, we propose an
alternative approach, allowing all of a mechanism to be formal and explicit. We
present (i) a taxonomy of declarative rules which can be used to capture a wide
variety of negotiation mechanisms in a principled and well-structured way; (ii)
a simple interaction protocol, which is able to support any mechanism which
can be captured using the declarative rules; (iii) a software framework for nego-
tiation that allows agents to effectively participate in negotiations defined using
our rule taxonomy and protocol and (iv) a language for expressing aspects of
the negotiation based on OWL-Lite [4]. We provide examples of some of the
mechanisms that the framework can support.
1 Introduction
Recently there has been much interest in the role of dynamic negotiation in electronic
business transactions. For negotiation to take place between two or more parties, they
need to agree on what economists refer to as a market mechanism or negotiation
mechanism. This defines the rules of the “game” which the parties are engaged in and
so determines the space of the possible actions that they can take. Within this game,
each party adopts a strategy which determines exactly which actions they make (in
response to actions by other parties or external events) in an effort to maximise their
(individual or collective) gain. The mechanism must be public and shared by all par-
ties, while an individual’s strategy stays private, and is only revealed implicitly
through the actions they take. For example, consider a simple market mechanism for
an English auction. It is defined by the following rules: (i) the buyers can post bids at
any time; (ii) a bid is only valid if it is higher than the currently highest bid; (iii) ter-
*
This chapter is an updated and extended version of [1] C. Bartolini, C. Preist, N.R. Jennings
Architecting for Reuse: A Software Framework for Automated Negotiation, in F. Giunchiglia,
J. Odell, G. Weiß (Eds.) Agent-Oriented Software Engineering III, Springer-Verlag LNCS
2585/2003.

214 Claudio Bartolini, Chris Preist, and Nicholas R. Jennings
mination occurs when no buyer has posted a bid in the last five minutes; (iv) after
termination, the good is sold to the buyer with the current highest bid at the price bid.
The participants in the auction are constrained by these rules, but have a free
choice of what action to take within them. A simple strategy for a buyer in such an
auction is to set a maximum limit to the price they are willing to pay for the good, and
to bid whenever the current highest bid is held by another buyer and is lower than
their price limit.
In this chapter we consider mechanisms not strategies. In particular, we are con-
cerned with the definition of interaction protocols underpinning a mechanism, rather
than the emerging properties of the mechanism itself (for an example of the latter,
compare [5]). The protocol determines the flow of messages between participants,
specifying when an agent can send a message, and what messages it can send as valid
responses to specified incoming messages. For example, a negotiation protocol for the
English auction states that (among other things) that potential buyers send messages
specifying their bids to the auctioneer, and receive an accept or reject message in
response. When the auction terminates, all participants receive a message informing
them of who the winner is, and the winning bid.
Various protocols are used for automated negotiation. They can be one-to-one
(such as iterated bargaining [6]), one-to-many or many-to-many (such as auctions
[7]). However, most state-of-the-art multi-agent systems are designed with a single
negotiation protocol explicitly hard-coded in all agents (usually as finite state ma-
chines). This leads to an inflexible environment, only able to accept agents designed
for it. An advance on this is provided by standardization activities such as FIPA [2]
and WS-Agreement [3]. FIPA provides formal definitions of several standard negotia-
tion protocols. The FIPA protocol for an English auction, described informally above,
is shown in [8].
However, these negotiation protocols only formalise the interactions between the
agents involved. They specify the permissible flow of messages, but omit information
regarding other aspects of the rules of negotiation in a market mechanism.
For example, the FIPA English Auction protocol does not specify the criteria for a
bid being acceptable (i.e. that it must be greater than the current highest bid) or the
conditions under which the auction will terminate (i.e. that no bids have arrived in the
last few minutes). Hence, because the multi-agent environment does not make these
explicit, the designer of an agent using the protocol must be aware of these negotia-
tion rules and design their agent taking them into account. As a result of this, with the
exception of the interaction aspects, the negotiation mechanism is implicit in the de-
sign of the multi agent system [9].
All the considerations made above also apply WS-Agreement [3], a standard pro-
posed by The Global Grid Forum (GGF). WS-Agreement includes the definition of a
simple interaction protocol to support one-to-one negotiation, with the likely aim to
support different mechanisms in the future through definition of multiple interaction
protocols.
We propose an alternative to that currently adopted by FIPA and GGF. Our ap-
proach allows negotiation rules to be explicitly specified and categorised both at the
design and at the implementation stage of agent oriented software development. We
carry out an analysis of a generic negotiation process, which is able to capture com-
mon aspects of a wide variety of types of negotiation.

A Software Framework for Automated Negotiation 215
From there we derive: (i) a taxonomy of declarative rules which can be used to
capture a wide variety of negotiation mechanisms in a principled and well-structured
way and (ii) a simple interaction protocol, which is able to support any mechanism
which can be captured using the declarative rules. This approach has the following
advantages:
1. The generic negotiation process and rule taxonomy provide valuable conceptual
tools for software engineers designing multi-agent systems which involve negotia-
tion mechanisms. Their application will result in the mechanisms being repre-
sented in a more modular and explicit way than current approaches.
2. A set of rules together with an interaction protocol will fully specify a negotiation
mechanism. Because of this, all information required for the design of agents us-
ing the negotiation mechanism is explicit and well-structured. This makes agent
design and implementation easier, and reduces the risks of unintentional incorrect
behaviour. This also opens the door for future research into creation and analysis
of novel market mechanisms through exploration of new combinations of rules.
3. Because the rules specifying the negotiation mechanism are explicitly represented
in the system, it is possible for an agent to reason over them to determine its be-
haviour and strategy. Ideally, an agent would be able to participate effectively in
an arbitrary negotiation mechanism specified by any set of rules. Negotiation algo-
rithms have been developed that are able to participate in several different negotia-
tion mechanisms, and to adjust their behaviour depending on the details of the
mechanism. For example, [10] present an agent algorithm able to simultaneously
participate in multiple English, Dutch and Sealed Bid auctions, requiring details of
bid increments, closing times and sealed bid winner announcement times to de-
termine its exact behaviour. Using the negotiation framework that we present, an
agent using such an algorithm could identify auctions of different types by check-
ing the mechanism rules against templates, and could identify parameter values in
the rules to determine the mechanism details.
To demonstrate the validity of our approach, in this chapter we also describe a
software framework for automated negotiation that allows agents to effectively par-
ticipate in negotiations defined using our rule taxonomy and protocol. The software
framework can form a highly modular and reusable component in a multi-agent sys-
tem. It advances the state of the art beyond the negotiation protocol approach because
(i) it can be used to implement a wide variety of negotiation mechanisms simply by
instantiating it with appropriate sets of rules. (ii) It is easy to maintain and update. If a
software engineer determines that a particular negotiation must change its mechanism
(see [11]), all they need do is adjust the rules appropriately. (iii) Agents involved in
that negotiation can access the new rules, so at worst can identify that their current
behaviour is inappropriate and issue a warning. A more advanced agent would be able
to automatically modify their behaviour as necessary, provided the changes to the
mechanism were not too great.
The remainder of this chapter is organized as follows: section 2 describes the ge-
neric negotiation framework, built upon the definition of an abstract negotiation proc-
ess and a taxonomy for the rules of negotiation. Section 3 describes a prototype im-
plementation of the negotiation framework. Section 4 presents a number of sample
negotiation mechanisms that can be embodied by the framework. We discuss related
work in section 5 and move to the conclusions in section 6.

216 Claudio Bartolini, Chris Preist, and Nicholas R. Jennings
2 The Generic Negotiation Framework
In this section, we present an abstraction of the negotiation process, developed from
the analysis of many different negotiations, both automated and human. From this, we
develop a general protocol for negotiation.
2.1 An Abstract Negotiation Process
The roles involved in the negotiation process are negotiation participant and negotia-
tion host. In some market mechanisms participants address one another, whereas in
others (e.g. auctions), participants send messages to a negotiation host that forwards
them to other participants that have the right and interest in seeing them. Our abstrac-
tion is that participants always publish their proposals on a common multicast space,
the negotiation locale, which is managed by the negotiation host. The negotiation
locale can be considered as a form of blackboard, with access to write and visibility of
information on it mediated by the negotiation host. Visibility rules are associated to
proposals so that only the participants that have right to see them can see them. This
allows us to see one-to-one and one-to-many negotiation as a particular case of many-
to-many
1
.
The agent playing the host role may also play a participant role (e.g. in one-to-one
negotiation) or may be non-participatory (e.g. the auctioneer in an auction). In some
cases, the role of negotiation host may alternate between different entities as the nego-
tiation progresses.
The first action to be taken is for a participant to require admission to the negotia-
tion. Much like in [13], admission consists of a simple conversation between the par-
ticipant and the host where the participant requests admission to a particular negotia-
tion and presents its credentials. Based on the credentials that the participant presents,
the negotiation host decides whether to admit the participant to negotiation and in-
forms the participant of the decision. If the participant is admitted, then we move onto
the negotiation itself. The admission step is very important because it is when partici-
pants are informed of the rules of negotiation. To be able to negotiate with one an-
other, parties must initially share a negotiation template. This specifies the different
parameters of the negotiation (e.g. product type, price, supply date etc). Some pa-
rameters may be constrained (e.g. product type will almost always be constrained in
some way), while others may be completely open (e.g. price). A negotiation locale
has a negotiation template associated with it and this defines the object of negotiation
within the locale.
As part of the admission process to the negotiation, participants must accept the
negotiation template. The constraints expressed in the negotiation template remain
static as the negotiation proceeds.
1
This model always requires the participants to trust the negotiation host. Trust issues between
participants and the negotiation host are addressed through the use of convertible undeniable
signatures [12]. The imposition that proposals have to be signed with convertible undeniable
signatures gives the protocol the following desirable properties. Even though proposals are
invisible to the negotiation host, when an agreement is formed (i) participants cannot falsely
claim ownership of the proposals and (ii) participants cannot repudiate the proposals that
they have submitted, unless by refusing to collaborate in a revelation process.

A Software Framework for Automated Negotiation 217
The process of negotiation is the move from a negotiation template to an accept-
able agreement. A single negotiation may involve many parties, resulting in several
agreements between different parties and some parties who do not reach agreement.
For example, a stock exchange can be viewed as a negotiation where many buyers
and sellers meet to trade a given stock. Many agreements are formed between buyers
and sellers, and some buyers.
During negotiation, the participants exchange proposals representing the agree-
ments currently acceptable to them. Each proposal will contain constraints over some
or all of the parameters expressed in the negotiation template. These proposals are
sent to the negotiation host. However, before a proposal is accepted by the locale, it
must be valid. To be valid, it must satisfy two criteria:
It must be a valid restriction of the parameter space defined by the negotiation
template. The constraints represent the values of parameters that are currently ac-
ceptable. Often, a constraint will consist of a single acceptable value.
The proposal must be submitted according to the set of rules that govern the way
the negotiation takes place. These rules specify (among other things) who can
make proposals, when they can be made, and what proposals can be submitted in
relation to previous submissions. For example, auctions often have a “bid im-
provement” rule that requires any new proposal to buy to be for a higher price
than previous proposals. Such rules are specified and agreed at the admission
stage.
An agreement is formed according to the agreement formation rules associated
with the negotiation locale. When the proposals in the locale satisfy certain condi-
tions, they are converted by these rules into agreements, and returned to the propos-
ers. The end of a negotiation is determined by termination rules. For example, in an
English auction the termination rule would state that the auction finishes when no
participant has placed a bid for a certain time, and the agreement formation rule
would state that an agreement is formed between the highest bidder and the seller, at
the price the bidder has bid.
This abstract process can be specialised to many different negotiation styles. For
example, in one-to-one bargaining, participants take turns in exchanging proposals in
a previously agreed format. The rules in this case are simple. Any proposal can be
made, as long as it is consistent with the negotiation template and made in turn. The
negotiation terminates when the same proposal is returned unchanged (which we take
as declaration of acceptance) or when one party leaves the negotiation locale. In the
former case, an agreement identical to the last proposal is formed. In an English auc-
tion, the proposals specify the price of the good, every other parameter being fully
instantiated in the negotiation template. Negotiation rules state that every new pro-
posal (bid) will be valid only if it is an improvement over the current best proposal.
Termination occurs at a deadline, and the agreement formed will contain the specifi-
cation of the good as expressed in the negotiation template, at the price specified in
the winning bid.
2.2 Taxonomy of Rules for Negotiation
So far we have been talking about negotiation rules in a very generic fashion. It is
useful at this point to divide the negotiation rules into categories. By examining the

Citations
More filters
Journal ArticleDOI
TL;DR: A generic framework for automated negotiation is introduced, in detail, the components of the framework are described, the sophistication of the majority of work in the AI literature on these components are assessed, and a number of prominent models of negotiation are discussed.
Abstract: Automated negotiation systems with software agents representing individuals or organizations and capable of reaching agreements through negotiation are becoming increasingly important and pervasive. Examples, to mention a few, include the industrial trend toward agent-based supply chain management, the business trend toward virtual enterprises, and the pivotal role that electronic commerce is increasingly assuming in many organizations. Artificial intelligence (AI) researchers have paid a great deal of attention to automated negotiation over the past decade and a number of prominent models have been proposed in the literature. These models exhibit fairly different features, make use of a diverse range of concepts, and show performance characteristics that vary significantly depending on the negotiation context. As a consequence, assessing and relating individual research contributions is a difficult task. Currently, there is a need to build a framework to define and characterize the essential features that are necessary to conduct automated negotiation and to compare the usage of key concepts in different publications. Furthermore, the development of such a framework can be an important step to identify the core elements of autonomous negotiating agents, to provide a coherent set of concepts related to automated negotiation, to assess progress in the field, and to highlight new research directions. Accordingly, this paper introduces a generic framework for automated negotiation. It describes, in detail, the components of the framework, assesses the sophistication of the majority of work in the AI literature on these components, and discusses a number of prominent models of negotiation. This paper also highlights some of the major challenges for future automated negotiation research.

141 citations


Cites background from "A software framework for automated ..."

  • ...Bartolini et al. (2005) characterize the negotiation design space in terms of declarative rules....

    [...]

  • ...Bartolini et al. (2005) characterize the negotiation design space in terms of declarative rules. The authors present a conceptual framework built upon an abstract negotiation process (a generic process incorporating aspects of both human and automated negotiation), a taxonomy of negotiation rules (e.g., rules for admission, proposal validity, updating status, and termination), and an interaction protocol (a generic protocol specifying the flow of messages and involving three main phases, namely admission, proposal submission, and agreement formation). Additionally, they describe a prototype implementation of the framework. Kersten and Lai (2007) focus on software systems to support and automate negotiation....

    [...]

Proceedings ArticleDOI
10 May 2010
TL;DR: In this paper, a highly flexible market platform is introduced for coordinating self-interested energy agents representing power suppliers, customers and prosumers that supports various market structures ranging from a single local energy exchange to a hierarchical energy market structure.
Abstract: The trend towards renewable, decentralized, and highly fluctuating energy suppliers (e.g. photovoltaic, wind power, CHP) introduces a tremendous burden on the stability of future power grids. By adding sophisticated ICT and intelligent devices, various Smart Grid initiatives work on concepts for intelligent power meters, peak load reductions, efficient balancing mechanisms, etc. As in the Smart Grid scenario data is inherently distributed over different, often non-cooperative parties, mechanisms for efficient coordination of the suppliers, consumers and intermediators is required in order to ensure global functioning of the power grid. In this paper, a highly flexible market platform is introduced for coordinating self-interested energy agents representing power suppliers, customers and prosumers. These energy agents implement a generic bidding strategy that can be governed by local policies. These policies declaratively represent user preferences or constraints of the devices controlled by the agent. Efficient coordination between the agents is realized through a market mechanism that incentivizes the agents to reveal their policies truthfully to the market. By knowing the agent's policies, an efficient solution for the overall system can be determined. As proof of concept implementation the market platform D'ACCORD is presented that supports various market structures ranging from a single local energy exchange to a hierarchical energy market structure (e.g. as proposed in [10]).

88 citations


Cites background from "A software framework for automated ..."

  • ...Open-outcry or English auction) and many-to-many relationship such as continuous double auctions [1]....

    [...]

  • ...There are several approaches how market processes can be formalized and described [12, 1, 13]....

    [...]

Proceedings ArticleDOI
18 Apr 2006
TL;DR: This paper proposes agent-based coordinated-negotiation architecture to ensure collective functionality, end-to-end QoS and the stateful coordination of complex services, and describes a prototype implementation to demonstrate how this architecture can be used in different application domains.
Abstract: Recent progress in the field of Web services has made it possible to integrate inter-organizational and heterogeneous services on the Web at runtime If a user request cannot be satisfied by a single Web service, it is (or should be) possible to combine existing services in order to fulfill the request However, there are several challenging issues that need to be addressed before this can be realized in the true sense One of them is the ability to ensure end-to-end QoS of a Web service composition There is a need for a SLA negotiation system which can ensure the autonomous QoS negotiation of Web service compositions irrespective of the application domain In this paper we propose agent-based coordinated-negotiation architecture to ensure collective functionality, end-to-end QoS and the stateful coordination of complex services We describe a prototype implementation to demonstrate how this architecture can be used in different application domains We have also demonstrated how the negotiation system on the service provider's side can be implemented both as an agent based negotiation system and as a Web service based negotiation system

81 citations


Cites background from "A software framework for automated ..."

  • ...The negotiation objects are the different parameters of negotiation such as price, time etc which can be predefined using a negotiation template [10]...

    [...]

Book ChapterDOI
John Wilkes1
17 Nov 2009
TL;DR: Buyya and Bobendorfer as mentioned in this paper provide an introduction to the use of utility theory with service level agreements between a computer-based service provider and a client, and argue that a consistent approach to utility, together with a flexible notion of pricing, can go a long way to clarifying some of the hidden assumptions that pervade many existing contracts and decisions around them.
Abstract: This paper provides an introduction to the use of utility theory with service level agreements between a computer-based service provider and a client. It argues that a consistent approach to utility, together with a flexible notion of pricing, can go a long way to clarifying some of the hidden assumptions that pervade many existing contracts and decisions around them. The goal is to enhance understanding of a surprisingly tricky area, identify a few consequences for services providers and their clients, suggest a set of terminology that reduces ambiguities, and make some suggestions for future work. External Posting Date: July 6, 2008 [Fulltext] Approved for External Publication Internal Posting Date: July 6, 2008 [Fulltext] A version of this paper will be published in Market Oriented Grid and Utility Computing, edited by Rajkumar Buyya and Kris Bobendorfer, published by John Wiley & Sons, Inc © Copyright 2008 Hewlett-Packard Development Company, L.P. Note: a version of this will appear as Chapter 4 in: Market Oriented Grid and Utility Computing, edited by Rajkumar Buyya and Kris Bubendorfer, and published by John Wiley & Sons, Inc., 2008. Utility functions, prices, and negotiation

65 citations

Journal ArticleDOI
01 Feb 2012
TL;DR: A new methodology made up of a generic framework for the main task, and a library of modular and reusable design pattern (templates) of subtasks that provides a basis for developing techniques to acquire the domain knowledge from human users is developed.
Abstract: Automated negotiation is widely applied in various domains. However, the development of such systems is a complex knowledge and software engineering task. So, a methodology there will be helpful. Unfortunately, none of existing methodologies can offer sufficient, detailed support for such system development. To remove this limitation, this paper develops a new methodology made up of (1) a generic framework (architectural pattern) for the main task, and (2) a library of modular and reusable design pattern (templates) of subtasks. Thus, it is much easier to build a negotiating agent by assembling these standardized components rather than reinventing the wheel each time. Moreover, because these patterns are identified from a wide variety of existing negotiating agents (especially high impact ones), they can also improve the quality of the final systems developed. In addition, our methodology reveals what types of domain knowledge need to be input into the negotiating agents. This in turn provides a basis for developing techniques to acquire the domain knowledge from human users. This is important because negotiation agents act faithfully on the behalf of their human users and thus the relevant domain knowledge must be acquired from the human users. Finally, our methodology is validated with one high impact system. © 2012 Wiley Periodicals, Inc.

61 citations

References
More filters
BookDOI
01 Jan 1999

2,795 citations

Book
18 Nov 2009
TL;DR: This introduction presents the main motivations for the development of Description Logics as a formalism for representing knowledge, as well as some important basic notions underlying all systems that have been created in the DL tradition.
Abstract: This introduction presents the main motivations for the development of Description Logics (DLs) as a formalism for representing knowledge, as well as some important basic notions underlying all systems that have been created in the DL tradition. In addition, we provide the reader with an overview of the entire book and some guidelines for reading it. We first address the relationship between Description Logics and earlier semantic network and frame systems, which represent the original heritage of the field. We delve into some of the key problems encountered with the older efforts. Subsequently, we introduce the basic features of DL languages and related reasoning techniques. DL languages are then viewed as the core of knowledge representation systems, considering both the structure of a DL knowledge base and its associated reasoning services. The development of some implemented knowledge representation systems based on Description Logics and the first applications built with such systems are then reviewed. Finally, we address the relationship of Description Logics to other fields of Computer Science.We also discuss some extensions of the basic representation language machinery; these include features proposed for incorporation in the formalism that originally arose in implemented systems, and features proposed to cope with the needs of certain application domains.

1,966 citations

01 Jan 1999
TL;DR: This paper presents the JADE software describing its intended uses, as well as being a walkthrough of JADE internal architecture, the main architectural issues are discussed, and the major design decisions are outlined.
Abstract: JADE is a software framework to develop agent applications in compliance with the FIPA specifications for interoperable intelligent multi-agent systems. The goal is to simplify development while ensuring standard compliance through a comprehensive set of system services and agents. JADE can then be considered an agent middle-ware that implements an Agent Platform and a development framework. It deals with all those aspects that are not peculiar of the agent internals and that are independent of the applications, such as message transport, encoding and parsing, or agent life-cycle. This paper presents the JADE software describing its intended uses, as well as being a walkthrough of JADE internal architecture. The main architectural issues are discussed, and the major design decisions are outlined.

1,207 citations


"A software framework for automated ..." refers background or methods in this paper

  • ...We have implemented the negotiation framework using the Jade multi-agent platform [15]....

    [...]

  • ...Mechanism design has recently had a surge in popularity [15, 5] as a foundation for building multi-agent software systems....

    [...]

01 Jan 2004

1,193 citations


"A software framework for automated ..." refers methods in this paper

  • ...For simplicity of exposition, here and in the following examples we will adopt a modified description logics notation [21] to express the proposals and the templates which is equivalent to the RDF OWL-Lite syntax [ 4 ]....

    [...]

  • ...The negotiation template and proposals are expressed as OWL-Lite descriptions [ 4 ]....

    [...]

  • ...... a wide variety of negotiation mechanisms in a principled and well-structured way; (ii) a simple interaction protocol, which is able to support any mechanism which can be captured using the declarative rules; (iii) a software framework for negotiation that allows agents to effectively participate in negotiations defined using our rule taxonomy and protocol and (iv) a language for expressing aspects of the negotiation based on OWL-Lite [ 4 ]....

    [...]

  • ...... a wide variety of negotiation mechanisms in a principled and wellstructured way; (ii) a simple interaction protocol, which is able to support any mechanism which can be captured using the declarative rules; (iii) a software framework for negotiation that allows agents to effectively participate in negotiations defined using our rule taxonomy and protocol and (iv) a language for expressing aspects of the negotiation based on OWL-Lite [ 4 ]....

    [...]

01 Jan 2004
TL;DR: This document describes Web Services Agreement Specification (WS-Agreement), a Web Services protocol for establishing agreement between two parties, such as between a service provider and consumer, using an extensible XML language for specifying the nature of the agreement, and agreement templates to facilitate discovery of compatible agreement parties.
Abstract: This document describes Web Services Agreement Specification (WS-Agreement), a Web Services protocol for establishing agreement between two parties, such as between a service provider and consumer, using an extensible XML language for specifying the nature of the agreement, and agreement templates to facilitate discovery of compatible agreement parties. The specification consists of three parts which may be used in a composable manner: a schema for specifying an agreement, a schema for specifying an agreement template, and a set of port types and operations for managing agreement life-cycle, including creation, expiration, and monitoring of agreement states. GFD-R-P.107 March 14, 2007 Grid Resource Allocation Agreement Protocol (GRAAP) WG graap-wg@ogf.org 2 Table of

959 citations

Frequently Asked Questions (2)
Q1. What have the authors contributed in "A software framework for automated negotiation*" ?

In this chapter, the authors propose an alternative approach, allowing all of a mechanism to be formal and explicit. The authors present ( i ) a taxonomy of declarative rules which can be used to capture a wide variety of negotiation mechanisms in a principled and well-structured way ; ( ii ) a simple interaction protocol, which is able to support any mechanism which can be captured using the declarative rules ; ( iii ) a software framework for negotiation that allows agents to effectively participate in negotiations defined using their rule taxonomy and protocol and ( iv ) a language for expressing aspects of the negotiation based on OWL-Lite [ 4 ]. The authors provide examples of some of the mechanisms that the framework can support. 

The authors believe that their framework covers a wide variety of negotiation mechanisms of which they give a flavor in section 4 - and gives a mechanism designer the possibility of easily creating new combination of negotiation rules.