MARGO: Arguing for negotiating a service

The ARGUGRID project aims at developing a Grid/Service-oriented platform populated by software agents acting on behave of service requesters and service providers. Argumentation technology is used to support rational decision making, internal to agents, as well as negotiation amongst agents. In this demonstration, we show how MARGO, the argumentation-based engine developed in the ARGUGRID project, can be used for service negotiation.

The ARGUGRID project aims at developing a Grid/Service-oriented platform populated by software agents acting on behave of service requesters and service providers. Within ARGUGRID, agents are associated with service/resource requesters and service/resource providers. Argumentation technology is used to support rational decision making, internal to agents, as well as negotiation amongst agents. With the support of argumentation processes, the agents decide which services can be used for fulfilling the demands of users and the constraints posed by providers, taking into account their preferences and the utilities they assign to situations, and evolving and using a notion of trust to "filter" their interactions with other entities. In this paper, we demonstrate how MARGO, the argumentation-based engine developed in the ARGUGRID project, can be used for service selection.

The ARGUGRID platform (cf Fig. 1) consists of four interacting components.

KDE is a commercial software tool developed by InforSense Ltd. This system provides facilities to build end user application as remote web services or Grid services.

GRIA is the GRID middleware that ARGUGRID has chosen to use. GRIA is a service-oriented infrastructure designed particularly to support Business-to-Business collaborations.

PLATON (Peer-to-Peer Load Adjusting Tree Overlay Networks) is a Peer-to-Peer platform supporting multi-attribute and range queries which has been developed in the project to supports service discovery mechanisms for load-balancing of peer resources.

GOLEM (Generalized OntoLogical Environments for Multi-agent systems) is an agent environment middleware which has been developed in the ARGUGRID project. MARGO (Multiattribute ARGumentation framework for Opinion explanation) is the engine developed in the ARGUGRID project used by agents for service selection and for partner selection.

Fig. 1: The ARGUGRID Platform

We intend to validate the ARGUGRID approach by way of industrial application scenarios.

In order to illustrate our negotiation model, we consider an electronic-procurement scenario where a buyer seeks to purchase a service s(x) (e.g. an Internet connexion). Each agent is representing a user, i.e. a service requester or a service provider. The exchange of offers and acceptances may lead to contracts, i.e. legal relations between providers and requesters that typically force commitments (e.g. obligations) from one agent to another about the provision of services. Then, each agent may be responsible for many different concrete instances of services: s(a), s(b), s(c) and s(d). These four concrete services reflect the combinations of their features: s(a)$ where warranty is low and price is low, s(b) where warranty is high and price is low, s(c) where warranty is low and price is high, and s(d)$ where both are high.

Domain description

epistemicrule(f1,price(a,low),[]).
epistemicrule(f2,warranty(a,low),[]).

epistemicrule(f3,price(b,low),[]).
epistemicrule(f4,warranty(b,high),[]).

epistemicrule(f5,price(c,high),[]).
epistemicrule(f6,warranty(c,low),[]).

epistemicrule(f7,price(d,high),[]).
epistemicrule(f8,warranty(d,high),[]).

According to the preferences and constraints of the buyer:

• the cost of the service must be low (e.g. within a budget of 10 euros per month), and
• the quality of the service must be high (e.g. with warranty of a 24 hours assistance).

Buyer

% ==================================================== %
% Buyer Example for Minimal concession         	       %
% ==================================================== %

:- compile('../../src/margo.pl').
:- multifile decision/1, incompatibility/2, sincompatibility/2, 
	goalrule/3, decisionrule/3, epistemicrule/3,
	goalpriority/2, decisionpriority/2, epistemicpriority/2,
	assumption/1, confidence/2.
:- compile('products.pl').
out(P):- assert(P).%For Interprolog

goalrule(r012(X),provision(X),[cost(X), qos(X)]).
goalrule(r01(X),provision(X),[cost(X)]).
goalrule(r02(X),provision(X),[qos(X)]).

decisionrule(r11(X), cost(X), [s(X), price(X,low), wn(rejected(X))]).
decisionrule(r22(X), qos(X), [s(X), warranty(X,high), wn(rejected(X))]).

goalpriority(r012(_), r02(_)).
goalpriority(r02(_), r01(_)).

decision([s(_)]).

According to the preferences and constraints of the seller:

• the cost of the service must be high (e.g. within a budget of 40 euros per month), and
• the quality of the service must be low (e.g. with warranty of a 2 hours daily assistance).

Seller

% ==================================================== %
% Seller Example for Minimal concession                %
% ==================================================== %
:- compile('../../src/margo.pl').
:- multifile decision/1, incompatibility/2, sincompatibility/2, 
	goalrule/3, decisionrule/3, epistemicrule/3,
	goalpriority/2, decisionpriority/2, epistemicpriority/2,
	assumption/1, confidence/2.
:- compile('products.pl').
out(P):- assert(P).% For Interprolog

goalrule(r012(X),provision(X),[cost(X), qos(X)]).
goalrule(r01(X),provision(X),[cost(X)]).
goalrule(r02,provision,[qos]).

decisionrule(r12(X), cost(X), [s(X), price(X,high), wn(rejected(X))]).
decisionrule(r21(X), qos(X), [s(X), warranty(X,low), wn(rejected(X))]).

goalpriority(r012(_), r01(_)).
goalpriority(r01(_), r02(_)).

decision([s(_)]).

Taking into account theirs goals and preferences/constraints, the buyer (resp. seller) needs to solve a decision-making problem where the decision amounts to a service it can buy (resp. provide).

This protocol only allows one kind of locutions: offer. It is worth noticing that the content of a speech act should be a fully instantiated proposal. Therefore, the following moves as legal:

• a first offer of the initiator (we decide that the buyer is the initiator);
• a reply offer from the hearer of the previous move to the speaker of the previous move.

According to the protocol, an history is final:

• and it is a failure, if last 3 offers of the sender of the current move are equals
• and it is success, the last two offers are equals

The agents bargain by successively putting forward offers. A bargaining is defined as a sequence of alternating offers and counter-offers between the buyer and the seller. An agent could accept an offer or reject it and then make a counter-offer. Reciprocity is a key principle in negotiation. There is no meaningful negotiation without reciprocity. An agent is said to adhere to the principle of reciprocity if, whenever the other agent has made a concession, it will reciprocate by conceding as well. We say that an agent concedes if its previous offer is preferred to the current one. Otherwise the agent is said to stand still.

Java code of the whole strategy

    // Calculate An Acceptable Proposal
    acceptableproposal= new String(this.calculate());
    //Strategy: concede if this is the 3rd move or the last received offer is a standstill  
    if (dialogue.isThirdMove() || ! this.hasReceivedStandstill()){
      String concession= new String(this.delete());
      if (concession.equals("no")){
	this.makeProposal(acceptableproposal);
	System.out.println(name+": my offer (standstill, since no more concession) is "+acceptableproposal);	  
      }
      else{
	acceptableproposal=concession;//compute the concession
	this.makeProposal(acceptableproposal);
	System.out.println(name+": my offer (concede) is "+acceptableproposal);	  
      }
    }
    //Strategy: standstill if last received messages is standstill 
    else {
      if (acceptableproposal != null) {
	this.makeProposal(acceptableproposal);
	System.out.println(name+": my offer (standstill) is "+acceptableproposal);	  
      }
      else{// initial conditions are not reached
	System.out.println(name+": I do not have any offer (exception)"+acceptableproposal);	  
      }
      }
    //Protocol: Is the dialogue is closed
    if (dialogue.isClosed()) {
      System.out.print(name+": that's all folk for me");	
      if (dialogue.isSuccessful()) System.out.println(" the bargaining was successful");	
      else System.out.println(" the bargaining failed");	
      this.stop();
    }

A concession is performed by noticing that the previous alternative has been rejected.

Java code for conceding

    String alternative=new String(getAcceptableAlternative());
    System.out.println(name+": delete the previously admissible decision "+alternative);	  
    engine.deterministicGoal("assert(epistemicrule(f"+alternative"+,rejected("+alternative+"),[]))");
    bindings =  engine.deterministicGoal("admissibleArgument(provision(X), _, SUPP), buildTermModel(SUPP,TM)","[TM]");

The terms & conditions considered for the evaluation of the contract about s during the negotiation are represented at the two axis of the two dimension plot represented in the figure below. The acceptability space of the two participants is represented by shaded areas and depends on the price (y-axis) and the warranty (x-axis). As said previously, the four points of intersection reflect the combinations of their values. After the message M2 (cf left of the figure), the seller only finds s(b) acceptable and the buyer only finds s(c). After the message M3 (cf center of the figure), the acceptability spaces of the two agents have shifted since both s(c) and s(b) have been rejected. Both of the agents make concession since the MARGO mechanism allow to relax the preferences. After the message M4 (cf right of the figure), both agents has identified s(d) as a common solution.

Figure: The acceptability spaces

Trace the process

Buyer: calculate the admissible decision:s(b)
Buyer: my first initial offer (standstill) is s(b)
Seller: calculate the admissible decision:s(c)
Seller: my offer (standstill) is s(c)
Buyer: calculate the admissible decision:s(b)
Buyer: delete the previously admissible decision b
Buyer the new admissible decision s(d)
Buyer: my offer (concede) is s(d)
Seller: calculate the admissible decision:s(c)
Seller: delete the previously admissible decision c
Seller the new admissible decision s(d)
Seller: my offer (concede) is s(d)
Seller: that's all folk for me the bargaining was successful
Buyer: that's all folk for me the bargaining was successful

Figure: The negotiation process

In this demonstration we have shown how argumentation can be used for supporting multi criteria negotiation making with concession, by providing a multi-agent technology for it.

Currently, we are applying our multi-agent technology to support argumentation-based negotiation in the particular context of e-business.

This works is supported by the Sixth Framework IST programme of the EC, under the 035200 ARGUGRID project.

Copyright © 2008 Maxime Morge