methods for task allocation via agent coalition formationferber/m2r/biblio/ai1548.pdf ·...

Artificial Intelligence 101 (1998) 165–200

Methods for task allocation via agent coalitionformation✩

Onn Shehorya,∗, Sarit Krausb,ca The Robotics Institute, Carnegie-Mellon University, 5000 Forbes Ave, Pittsburgh, PA 15213, USAb Department of Mathematics and Computer Science, Bar Ilan University, Ramat Gan, 52900 Israelc Institute for Advanced Computer Studies, University of Maryland, College Park, MD 20742, USA

Received 17 April 1997; received in revised form 7 April 1998

Abstract

Task execution in multi-agent environments may require cooperation among agents. Given a setof agents and a set of tasks which they have to satisfy, we consider situations where each taskshould be attached to a group of agents that will perform the task. Task allocation to groups ofagents is necessary when tasks cannot be performed by a single agent. However it may also bebeneficial when groups perform more efficiently with respect to the single agents’ performance. Inthis paper we present several solutions to the problem of task allocation among autonomous agents,and suggest that the agents form coalitions in order to perform tasks or improve the efficiency oftheir performance. We present efficient distributed algorithms with low ratio bounds and with lowcomputational complexities. These properties are proven theoretically and supported by simulationsand an implementation in an agent system. Our methods are based on both the algorithmic aspects ofcombinatorics and approximation algorithms for NP-hard problems. We first present an approach toagent coalition formation where each agent must be a member of only one coalition. Next, we presentthe domain of overlapping coalitions. We proceed with a discussion of the domain where tasks mayhave a precedence order. Finally, we discuss the case of implementation in an open, dynamic agentsystem. For each case we provide an algorithm that will lead agents to the formation of coalitions,where each coalition is assigned a task. Our algorithms are any-time algorithms, they are simple,efficient and easy to implement. 1998 Published by Elsevier Science B.V. All rights reserved.

Keywords:Multi-agent cooperation; Coalition formation; Task allocation

✩ This material is based upon work supported in part by the NSF under grant. No. IRI-9423967 and ArmyResearch Lab under contract No. DAAL0197K0135. Preliminary results of this research were published in theproceedings of IJCAI-95 and ICMAS-96.∗ Corresponding author. Email: [email protected].

0004-3702/98/$19.00 1998 Published by Elsevier Science B.V. All rights reserved.PII: S0004-3702(98)00045-9

166 O. Shehory, S. Kraus / Artificial Intelligence 101 (1998) 165–200

1. Introduction

Autonomous agents in multi-agent environments may need to cooperate in order to fulfilltasks. Given a set of tasks to be satisfied, we consider situations where each task is assigneda group of agents to perform it. We address cases in which dependencies among tasks, ifsuch exist, are due to competing resources’ requirements or execution precedence order.The allocation of tasks to groups of agents is necessary when tasks cannot be performed bysingle agents or when single agents perform them inefficiently. Various groups of agentsmay have different degrees of efficiency in task performance due to differing capabilitiesof their members. Task allocation should be done with respect to these differences.

The purpose of the allocation of tasks to groups of agents is to maximize benefits viatheir performance. We seek an algorithm that will enable a distributed task allocation,i.e., without a central authority. A low computational complexity shall be considered animportant property for such a solution. Hence, in this paper we present algorithms thatenable the agents to form groups and assign a task to each group. We call these groupscoalitions. For the development of the required algorithms, we combine a combinatorialalgorithmic approach and concepts from operations research, with autonomous agents’methods and distributed computing systems methods. The coalitions the agents form whenusing these algorithms are beneficial for systems of cooperative agents, as we show inthis paper. We will concentrate on coalition formation in environments which are notnecessarily super-additive1 [11,21].

Distributed artificial intelligence (DAI) is concerned with problem solving in whichseveral agents interact in order to execute tasks. During the past few years, several solutionsto the coalition formation problem have been suggested by researchers in the field of DAI.These solutions concentrate on the special case of autonomous agents in a super-additiveenvironment [28,44,64]. Most of these solutions are given for coalition formation in Multi-Agent Systems (MAS), where each agent tries to increase its own personal utility viacooperation. One of the main problems of coalition formation in the case of MAS is howto distribute the common outcome of a coalition among its members. We present coalitionformation algorithms which are appropriate for Distributed Problem Solving2 (DPS) [6]cases where agents cooperate in order to increase the overall outcome of the system [45]and are not concerned with their personal payoffs as they are in MAS. In such cases, thedisbursements to the agents are not as important as they are in MAS. In addition, oursolution is not restricted to the super-additive environment. Since in the case of a super-additive environment the grand coalition is expected,3 a coalition formation process forDPS systems in super-additive environments shall be very simple. Conversely, the non-super-additive environment case is much more challenging and may be very realistic. Incases where the addition of every new agent to the coalition is costly,4 as the size of the

1 In a super-additive environment any combination of two groups of agents into a new group is beneficial. Fordetails see Section 3.

2 Recently, DPS agent systems are referred to as cooperative MAS [52].3 A grand coalition is a coalition that includes all of the agents [43].4 Such costs may arise from the intra-coalition coordination and communication costs; these increase with the

size of the coalition.

O. Shehory, S. Kraus / Artificial Intelligence 101 (1998) 165–200 167

coalition increases, it may becomes non-beneficial to form it. We suggest a solution whichis most appropriate for such non-super-additive cases.

We begin by illustrating the problem we intend to solve (Section 2). Then, we give abrief description of the environment with which we deal in Section 3. We also brieflypresent the basic definitions and assumptions in Section 3.1 and the set covering and setpartitioning problems in Section 3.2. The algorithms are described in Sections 4 and 5,their ratio bounds are discussed in Section 6, and their complexity is analyzed in Section7. Section 8 contains the simulation results and their analysis, and in Section 9 we discussthe requirements and properties of an implementation in an open MAS. Related research isreferred to in Section 10, and Section 11 ends our paper with a discussion and conclusions.

2. Illustration of the problem

The problem we solve in this paper is that of task allocation among groups ofautonomous agents in a DPS system. Given a set of tasks, the system as a whole must seeka maximization of its benefits by satisfying tasks.5 We consider cases where tasks mayhave a precedence order. We assume no central authority that distributes the tasks amongthe agents. Therefore, they shall reach an efficient task allocation by themselves, seekinga maximal outcome. This is achieved via the formation of coalitions, possibly overlappingones.

Schema 1.

5 Ideally, all of the tasks should be satisfied, however when attempting to maximize benefits, the execution ofsome tasks may be hindered.


We demonstrate the problem using a Blocks World domain as Schema 1. The blocks areof various sizes (for simplicity, we consider the case of a unit block and a row of attachedunit-blocks). Each unit-block weighs one weight-unit. The blocks should be moved fromthe initial configuration to the final configuration. This should be done by a group of agents,each capable of lifting a limited weight (e.g., 2 weight-units) and moving it aside as muchas necessary. Each block can be carried by a limited number of agents (due to physicallimitations). We do not discuss the planning problem but assume a previously providedplan. This plan shall divide the goal into subgoals with a precedence order. Such subgoals,which are part of the global plan, are presented in Schema 2. In such a subgoal, one cannotplace blockC before blocksA andB are properly located. In addition, cooperation amongagents is necessary. BlockC cannot be lifted by one agent. However, 4 agents can do so butless efficiently, due to coordination costs, and 20 of them will be far too many. Obviously,any member of the group that placesC may be a member of a group that placesA or B.However, if the agents have a limited amount of fuel, they may cease functioning afterperforming a set of tasks, and therefore they cannot be part of all working groups.

Schema 2.

The global goal may be partitioned into several subgoals. For instance, it may bepartition to three subgoals: subgoal I—locate blocksA1,B1,C1; subgoal II—locate blocksA2,B2,C2; subgoal III—locate blockC3. Each of these subgoals can be performed by acoalition of agents, and subgoal III can be performed only after subgoals I and II have beenperformed. Members of the coalitions that perform either subgoal I (CI ) or subgoal II (CII )may be members of the coalition that performs subgoal III. It may also be possible thatmembers ofCI be members ofCII and vice versa. However, to increase the efficiency ofthe performance of subgoals I and II,CI andCII should not have any common members.This will enable the performance of subgoals I and II simultaneously, thus saving time andavoiding an intra-coalitional coordination overhead that arises from larger coalitions.

Another example of our problem may be a transportation company.6 The company sup-plies transportation services via a system of autonomous and automated trucks, lift trucks,

6 Transportation systems have been extensively used as examples for DPS systems (e.g., [41]). We do not intendto solve a specific transportation problem. However, we provide this example because the reader may be familiarwith it.


cranes, boats and planes which we refer to as agents. This system is usually arranged in adistributed manner, since every single agent may perform limited tasks by itself. The agentsdiffer in their capabilities. That is, they differ in the type of actions that they can perform,in the size, volume and weight of goods that they can carry at one time, in the transporta-tion speed, its costs and the method by which it is performed. There may be occasionswhere agents cannot perform a given transportation task by themselves. In such cases, co-operation is necessary. Therefore, the agents shall form groups, and each group of agentswill cooperatively fulfill a transportation task. We call such cooperating groupscoalitions.Some coalitions may be unable to perform some tasks. Some tasks cannot be performedunless other tasks have been satisfied prior to their performance. Among the coalitions thatare able to perform a given task, the efficiency and the costs may be completely different.

For example, suppose that a task of taking 10 passengers from Mirabel airport to Dorvalairport (both in Montréal) has been ordered. This may be performed by several private carsor by a single helicopter. However, using a helicopter in such a case will probably costmuch more than using private cars and take approximately the same time (due to flightconstraints and regulations). Therefore, the most appropriate coalition in such a case is acoalition of private cars. This coalition shall be such that it consists of the optimal numberof cars as per number of passengers. An excess of agents in the coalition may be costlyeither for the coalition members or for the system as a whole, or both. This is due to thecommunication, coordination and internal organization costs, both for the formation of thecoalition and for its maintenance. These costs are an increasing function of the size of thecoalition. In the case of disjoint coalitions, an overhead of agents in a coalition may preventthe formation of other beneficial coalitions and may therefore reduce the total outcome ofthe system.

The transportation company may have many agents, and therefore a central authorityfor coalition formation may be too costly in time and computational efforts. Using a dis-tributed task allocation mechanism rather than a centralized one may be advantageous (asdiscussed in Section 7). In such cases task allocation and cooperation shall be decidedupon locally. However, such a company seeks the maximization of its benefits. Therefore,the company shall attempt to satisfy beneficial transportation orders, mainly to bring animmediate profit, but also to satisfy clients (which is important for the company’s future).Since a single agent cannot always satisfy a client’s order, close cooperation is necessary.For such cases, the company shall provide the agents with a simple but also efficient algo-rithm that will enable the formation of coalitions of agents.

The problem of the transportation company is generalized in this paper. We provide al-gorithms which enable the allocation of tasks among a system of agents via the formationof coalitions. We show that the algorithms are simple to implement, have a short run-time(hence can be used as a real-time method), and yield results which are close to the optimalresults.

3. Environment description

In order to elucidate the problem and its solution, we briefly present some generalnotations and definitions of concepts. We assume that agents can communicate, negotiate


and make agreements [59]. Communications require time and effort on the part of theagents. We also assume that resources can be transferred between agents. This abilitymay help the agents form more beneficial coalitions. Agreement on cooperation may bereached even if the last assumption is not valid (e.g., [1,2,29,62]). However, the possibilityof goods transferability (or alternatively, side-payments) may help the agents form morebeneficial coalitions. To emphasize the non-super-additivity property of the environmentwith which we deal, we assume that the addition of agents to a coalition is costly, andtherefore expanding coalitions may be non-beneficial. Without this assumption, the grandcoalition, as a coalition that consists of all of the formed coalitions within it, would be themost beneficial.

3.1. Definitions

We recall the following definitions as presented in [45,46]. There is a set ofn agents,N = {A1,A2, . . . ,An}. Each agentAi has a vector of real non-negative capabilitiesBi = 〈bi1, . . . , bir〉. Each capability is a property of an agent that quantifies its ability toperform a specific action. These capabilities are either expendable or non-expendable (e.g.,the carrying capability in the Blocks World). The expendability of the capabilities affectsthe overall task execution of the agent system. Recalling the transportation company,the volume and weight that can be transported by an agent is its transportation-volumecapability. In order to enable the assessment of coalitions and of task execution, anevaluation function shall be attached to each type of capability. Such a function shalltransform the capability units into monetary units. In the transportation case, this functionmay be the income from performing a task. This may be a linear function of the number ofpassengers. We also assume that there is a set ofm independent tasks7 T = {t1, t2, . . . , tm}.For the satisfaction of each tasktl , a vector of capabilitiesBl = 〈bl1, . . . , blr〉 is necessary.The utility gained from performing the task depends on the capabilities that are requiredfor its performance. In our solution we assume, to simplify the calculations, that the utilitygained is a linear function of the resource amount.

There may be occasions where a specific tasktj cannot be performed unless anotherspecific taskti has already been satisfied. This is generalized by a partial precedence orderbetween the tasks,t11 � t12 � · · · � t1n1

, . . . , tk1 � tk2 � · · · � tknk , whereti � tj meansthat ti is the predecessor oftj and tj is the successor ofti in the performance order.The precedence order and the resource consumption are the only dependencies that weassume. This restricts our solution to cases where no other explicit dependencies exist (thisis appropriate for various domains, including the Blocks World and several transportationdomains).

A coalition can be defined as a group of agents who have decided to cooperate in orderto achieve a common task. We assume that a coalition can work on a single task at atime, and that each agent may sometimes be a member of more than one coalition. The

7 The partition of a single task into subtasks is beyond the scope of this paper. However, if these subtasks areindependent, then the algorithms that we suggest can be used recursively to allocate subgroups of agents to thesubtasks. In cases where there are interdependencies (which are not precedence dependencies) among tasks, wesuggest to combine dependent tasks into unified tasks. The recognition of such dependencies can be performedby implementing techniques from constraint satisfaction research (see [35,37]).


latter assumption can increase an agent’s ability to use its resources for task execution.A coalitionC has a vector of capabilitiesBc which is the sum of the capabilities that thecoalition members contribute to this specific coalition. Note that in the case of overlappingcoalitions this sum is not the sum of all of the capabilities of the members, because theagents may be members of more than one coalition, and can contribute part of theircapabilities to one coalition and part of them to another. A coalitionC can perform atask t only if the vector of capabilities necessary for its fulfillmentBt satisfies∀06 i 6r, bti 6 bCi and, in the case of precedence order,t has no unsatisfied predecessors. Foreach coalitionC a valueV can be calculated8 which is the joint utility that the membersof C can reach by cooperating via coalitional activity for satisfying a specific task.9

The coalitional valueV is directly affected by the capabilities that the members of thecoalition contribute to it, the precedence order of the tasks and the number of coalitionmembers. In the case of overlapping coalitions, a method is required according to whichthe agents decide how to partition their capabilities between coalitions in which they aremembers. This method is provided in the corresponding coalition formation algorithm,in Section 4. Recall the transportation company: given a specific transportation task, ifthe sum of transportation volumes of a coalition is less than the volume necessary forthe task, then the value of the coalition for this specific task is zero. If the coalitionaltransportation volume is much greater than necessary for satisfying the task, then the valueis positive, but relatively small compared to the case of having the exact volume. Actually,the transportation volume is not the only capability of the agents and therefore does notaffect the coalitional value exclusively.

To conform with a common representation, we may employ the notion of coalitionalcost c instead of coalitional value. This cost may be calculated as the reciprocal of thecoalitional value or as its negation. Such a calculation attaches a low cost to a high-valued coalition and vice versa. The coalitional rationality (as described below), whichleads agents to try to increase the coalitional value, likewise leads them to try to reduce thecoalitional cost.

We assume that the agents are group-rational. That is, they form a coalition only if theybenefit as a coalition at least as much as the sum of their personal benefits outside of it [22,33,39]. The agents benefit if they fulfill tasks. Group rationality is necessary to ensure thatwhenever agents form a coalition, they increase the system’s common outcome, which isthe sum of the coalitional outcomes. We also assume that each agent tries to maximize thecommon utility; among all of the possibilities that an agent has, it will choose the one thatwill lead to the maximum common utility. However, group rationality of the agents doesnot necessarily entail a super-additive environment. In order to emphasize the differencebetween the super-additive environment and the ones with which we deal, we describe thesuper-additive environment below.

8 The calculation of coalitional values is, in the general case, rather complex. Nevertheless, low complexityapproximation methods for calculating values of agreements among multiple agents have been recently developed[26], and these can be utilized for our case.

9 This notion of coalitional value is different from the notion commonly used for coalitional values in gametheory, since here the value depends on the coalitional configuration and on the task allocation.


A super-additive environment is such that the set of the possible coalitions satisfiesthe following rule: for each pair of coalitionsC1, C2 in the set,C1 ∩ C2 = ∅, if C1, C2join together, then the newly formed coalition will have a new valueV new

C > V 1C + V 2

C ,whereV 1

C , V 2C , V new

C are the values of the coalitionsC1, C2 andCnew, respectively.10

Rational agents in a super-additive environment will prefer the grand coalition over allother coalitions. Hence, in a super-additive environment, when the grand coalition isformed, the only problem that remains is the utility distribution among its members. This isa major problem in MAS, however, in DPS systems such a problem is of lesser importanceor may not exist at all.

More assumptions are as follows: we assume that the agent population does not changeduring the coalition formation process. Wedo not assume complete information. Thatis, all of the agents must know about all of the goals and the existence of other agents,however only coalition members must know all of the details required for satisfying aspecific goal. Note that for implementation in a dynamic agent system, the assumptionsof a fixed agent population and full knowledge about goal and agent existence are laterrelaxed (in Section 9). Additional assumption are as follows: agents outside a coalitionC

need not know the details of the intra-coalitional activity withinC. Our algorithm shouldwork regardless of clock synchronization among the agents.11 That is, in order to decidewhich agent will perform what action, the agents do not have to know precisely when otheragents will act. Nevertheless, significant time differences between the agents’ clocks mayreduce the efficiency of the overall goal satisfaction.

Now that we have made the necessary assumptions and definitions, we can formallypresent the problem. Given a set ofm tasksT = {t1, . . . , tm}, with an (optional) precedenceorder and a set ofn agentsN = {A1, . . . ,An} with their capabilities, the problem we solveis of assigning tasksti ∈ T to coalitions of agentsCi ⊆ N such that

∑i Vi (the total

outcome) is maximal and the precedence order is respected as well. Note that while weinitially refer to T andN as fixed, we later allow them to change dynamically. We solvethe problem for the general case of non-super-additive environments. However, even in thecase of a super-additive environment, the solution will consist of coalitionsCi that do nothave null12 members. This is because the membership of null members in a coalition willprobably increase the coalitional costs thus reducing the overall outcome.

3.2. Set covering and set partitioning

Since task allocation among agents may be approached as a problem of assigning groupsof agents to tasks, the partition of the agents into subgroups becomes the main issue.Therefore, the task allocation problem becomes similar to the set partitioning and the setcovering problems.

Below we formulate the two problems: SCP and SPP. Given a setN = {A1, . . . ,An} anda set of subsets ofN , S = {C1, . . . ,Cm}, such thatCj ⊆N andS ⊆ 2N ; a set cover is any

10 Note that in our case there may be coalitionsC1, C2 andCnew such thatV newC

< V 1C+ V 2

C, however the

group rationality prohibits the formation of suchCnew’s.11 This assumption is only with regards to the requirements of our algorithm. The properties of the tasks of the

multi-agent system may require such a synchronization, independently of our algorithm requirements.12 Null members are agents that contribute nothing to the coalitional performance.


S′ ⊆ S, such that⋃Cj∈S ′ Cj =N . The members ofS′ are the covering sets. If the members

of S′ are also pairwise disjoint (i.e.,∀Ci,Cj ∈ S′, i 6= j, Ci ∩ Cj = ∅), thenS′ is a setpartitioning ofN . We assume that eachCj ∈ S has a positive costcj . The cost of a coverS′is∑Cj∈S ′ cj . The set covering problem entails finding the cover with the minimum cost,

and the set partitioning problem is defined correspondingly [3,4,20].The set covering problem is NP-complete [12]. Therefore, the optimal solution implies

an exponential computational complexity, which is too high for practical use. However, avariety of algorithms for solving this problem sub-optimally have been suggested, e.g., in[4,8,9]. Among them we can find the algorithm of Chvatal [9], which has a logarithmic ratiobound.13 Given its low ratio bound, it is very tempting to adopt and adapt this algorithmfor the case of multi-agent coalition formation. This cannot be done for the case of disjointcoalitions, since the algorithm provides a solution to the set covering problem, in whichsubgroups may overlap. Furthermore, even when overlapping coalitions are allowed otherdifficulties are still present. These include the following: the set covering problem dealsonly with a small given set of subsets, and in the case of agents, the number of possiblecoalitions is 2n (hence, we need heuristics for reducing this number); the algorithms forSCP and SPP are centralized and, since we deal with autonomous, distributed agents, weseek a distributed algorithm; the SCP and SPP algorithms do not refer to cases where thereis a precedence order between the chosen subgroups. Despite the deficiencies indicatedabove, we attempt to borrow some of the properties of the Chvatal’s algorithm, thusconstructing coalition formation algorithms with a low ratio bound.

4. The algorithms

The algorithms we present below are greedy distributed set partitioning and set coveringalgorithms with low ratio bounds. They were designed for the special case of autonomousagents in an environment which is not necessarily super-additive, and that work as a DPSsystem (i.e., they try to act in order to increase the performance and benefits of the group asa whole). The algorithms are any-time algorithms, that is, if the execution is stopped beforean algorithm would have normally terminated, it still provides the agents with a solutionwhich is better than their initial state or other preceding states.

The algorithms consist of two main stages (presented later in detail):(i) In the preliminary stage of each algorithm, all possible coalitions are distributively

calculated and their initial values are computed.(ii) The main stage of the algorithms consists of an iterative distributed greedy

procedure in which two sub-stages occur:– The coalitional values are re-calculated. This is done because an efficient

coalition formation algorithm requires up-to-date information about the valuesof the possible coalitions, to enable the choice of the preferred ones.

– The agents decide upon the preferred coalitions and form them.

13 An approximation algorithm for a problem has a ratio boundρ(n) if ρ(n) is smaller than the ratio betweenthe optimal cost and the approximated cost.


As previously stated, the solution of the SPP and the SCP in the case of autonomousagents are of an exponential complexity, since the number of the possible coalitions isexponential (2n). A reduction in this number is possible by limitations on the permittedcoalitions. This can be done via the constraints of the specific problem under investigation,e.g., it may happen that all of the tasks must be performed by the same number of agents.In case no specific limitations accrue from the properties of the specific problem, werecommend preferring small-sized coalitions. We justify such heuristics by the associatedcost estimation: since communication and computation time are costly, and the agentsseek cost reduction, they should try to avoid unnecessary communication and computationactivities. In this sense, small-sized coalitions are more economical to design than largercoalitions and therefore shall be preferred.14 This is the case since the calculations andcommunication operations are exponentially dependent on the numbers of members in acoalition. These heuristics will be implemented in our algorithms by presenting an integerk which will denote the highest coalitional size allowed. This restriction will limit thenumber of coalitions to O(nk), which is a polynomial number inn. However, this doesnot trivialize the problem since even with such restrictions, the problem remains NP-complete.15 In the transportation case, a limitation on the size of coalitions may be evenmore reasonable than in the general case. Here, it would be very convenient to assume thatthe volume of a single task never exceeds a given size. Such a restriction affects the numberof coalitions in the same way as in the case of communication and computation restrictions.Additional information about the properties of the tasks and the coalitional values mayenable the calculation of the expectation values of the outcome of different coalitions. Thisshall improve the heuristics we employ, thus reducing the number of coalitions and thecomplexity of the algorithm.

The initial coalitional state consists ofn, single agents. The agents then begin negotiating[31] and, step by step, form coalitions. In the case of disjoint coalitions, agents that joincoalitions quit the coalition formation process, and only the remaining single agents willcontinue negotiations. The reduction in the number of agents that continue negotiatingreduces the computational and communication costs. In the case of overlapping coalitions,agents that join coalitions do not quit the coalition formation process unless their resourcesare depleted. However, the overlapping property increases the efficiency of task executionand thus the benefits of the system.

4.1. Preliminary agreement on calculation distribution

Prior to forming the coalitions, the agents must agree on the distribution of valuecalculations among themselves. In order to achieve this distribution, each agentAi shouldperform the following steps:

14 Note that this seems to contradict the economies of scale principle. However, our coalitions are created forperforming a single task, and they afterwards decompose, whereas the principle of economies of scale refer tolong-lasting organizations which perform multiple tasks over time. Hence we find this concept inapplicable toour case. There may be, however, cases in which only large coalitions can satisfy the tasks. In such cases differentheuristics must be adopted.15 This is because the number of combinations of coalitions may still be exponential. This is similar to the NP

completeness of SPP and SCP which, too, refer to a small number of subsets.


(i) Calculate all of the permutations that include up tok agents includingAi and putin P i , the set of the potential coalitions of agentAi .

(ii) While Pi is not empty, do:– Contact an agentAj that is a member of a potential coalition inPi .– If this is the first contact withAj , locate information about its capabilities (i.e.,

retrieveBj ).– Commit to the calculation of the values of a subset16 Sij of the common

potential coalitions (i.e., a subset of the coalitions inPi in which bothAi andAj are members).

– SubtractSij fromPi . AddSij to your long-term commitment listLi .– For each agentAk that has contacted you, subtract fromPi the setSki of the

potential coalitions it had committed to compute values for.– Compute values for the coalitions you have committed to17 (Sij ), as detailed

below (Section 4.2, (i)–(iv)). If some capabilities are unknown, contact therelevant agents.18

– Repeat contacting other agents untilPi = {Ai} (i.e., no more agents to contact).After the preliminary stage, each agentAi has a listLi of potential coalitions for which ithad committed to repeatedly calculate the values, and their preliminary values. In addition,Ai has all of the necessary information about the capabilities of the members of thesecoalitions, and it updates the information if necessary.19

4.2. Distributed, repeated calculation of coalitional values

The coalition formation algorithms require repeated calculation of the coalitional values.As opposed to the common approach to coalitional values, the values in our model varycontinuously. Therefore, the calculations should be repeated iteratively. However, thecalculation in each iteration follows the same procedure, as described below. Note thatthis procedure is appropriate for either the overlapping or the non-overlapping cases. Forthe case of tasks with precedence order, some modifications will be necessary. The basicprocedure for calculating the coalitional values is presented below. In addition toLi , eachagentAi should maintain a list of the coalitions for which it should currently computevalues, denotedLcr

i , initially set20 to ∅. Given these lists, agentAi should perform thefollowing steps:

Loop and for each coalitionC on listLcri , perform:

16 The size of this subset may vary from a single coalition to all of the common coalitions. The agents shouldmake this decision with respect to their relative computation speed.17 Note that since agents may have different computation capabilities some will finish faster than others. These

will re-enter the loop and commit to another subset of potential coalitions. By this, the computations will bedistributed evenly with respect to computing speed.18 Instead, as done in the implementation (Section 9), agents can query a matchmaker for this information.19 Note that this does not require that each agent know all of the capabilities of all the others because they do

not necessarily compute coalitions where these agents are members. The necessity of agents’ knowledge aboutothers is further relaxed in the implementation in an open system, Section 9.20Lcr

iis initially ∅ because all of the values were calculated in the preliminary stage.


(i) Calculate the coalitional potential capabilities vectorBpcc , by summing up the

unused capabilities of the members of the coalition.21 Formally,Bpcc =∑Ai∈C Bi .

(ii) Form a list Ec of the expected outcomes of the tasks inT when coalitionCperforms them. For each tasktj ∈ T , perform:– Check what capabilitiesBj are necessary for the satisfaction oftj .– CompareBj to the sum of the unused capabilities of the members of the coalitionB

pcc , thus finding the tasks that can be satisfied by coalitionC.

– If ∀i, bij ∈ Bj 6 bipc ∈ Bpcc (that is, tj can be satisfied byC), calculatetj ’s

expected net outcomeej with respect to|C|. This shall be done by calculating thegross benefit acquired from the task execution. The latter is the sum of the marketvalues of the capabilities necessary for the execution oftj as expressed inBj .From the gross benefit, the sum of capabilities costs and internal coordinationcosts must be subtracted. This will be the expected net outcomeej of task tjwhen coalitionC performs it. Putej in Ec.

(iii) Among the expected outcomes on listEc, choose the maximal. This will be thecoalitional valueVc.

(iv) Calculate the coalitional cost which iscc = 1/Vc.In cases where computation is the bottleneck of the agent system, additional action on thepart ofAi may be necessary. IfAi has finished computing values for the coalitions inLcr

i

but another agent, for instanceAj , has not finished its computations,Ai should contactAjand commit to the computation of the values of a subsetScr

ij of Lcrj . Then,Ai should add

Scrij toLcr

i and repeat the iterative process above.Having calculated the coalitional values and costs, the agents can continue to the

proceeding steps of the coalition formation iteration.

4.3. Choosing coalitions

In this sub-stage, in each iteration of the algorithms, the agents decide step-by-stepwhich coalition should be preferred and formed, and the coalitional configuration isgradually achieved. At the end of the coalition value calculation sub-stage, each agentAi will have a listLi of coalitions and their values and costs which it had calculated. Inthis sub-stage, the agents shall form coalitions. Each agentAi shall iteratively perform asequence of steps. The overlapping coalitions’ case will require a sequence different fromthe disjoint coalitions’ case.

4.3.1. Disjoint coalitionsIn order to simplify the representation of the algorithm, we denote the ratio between

the cost of the coalition and the coalition’s size bywi = ci/|Ci | and call it the coalitionalweight. At the end of the first sub-stage of each iteration of the algorithm, each agent willhave calculated a list of coalitions and coalitional values and weights.

Each agentAi shall iteratively perform the following:(i) Locate inLi the coalitionCj with the smallestwj .(ii) Announce the coalitional weightwj that it has located.

21 Note that in the case of overlapping coalitions, this sum is notBc , the coalitional vector of capabilities.


(iii) Choose the lowest among all of the announced coalitional weights. Thiswlow willbe chosen by all agents. Choose the corresponding coalitionClow and tasktlow aswell.

(iv) Delete the members of the chosen coalitionClow from the list of candidates fornew coalitions.

(v) If you are a member of the chosen coalitionClow, join the other members andformClow.

(vi) Delete fromLi the possible coalitions that include deleted agents.(vii) Delete fromT the chosen tasktlow.(viii) Assign to Lcr

i the coalitions inLi for which values should be re-calculated (seedetails below).

The above procedures of calculating coalitional values and choosing the preferredcoalitions will be repeated until all agents are deleted (that is, until all are assigned tocoalitions), or until there are no more tasks to be allocated, or none of the possiblecoalitions is beneficial. Some of the coalitional values shall be re-calculated repeatedlysince values may be affected by variations in the coalitional configuration. This is becauseeach value is calculated subject to the tasks that should be performed. A change inthe coalitional configuration corresponds to an assignment of a task to a coalition. Thisspecific task no longer affects the coalitional values which it may have previously affected.Therefore, the coalitional values that have been calculated with respect to a task that hasjust been allocated must be re-calculated. All other values remain unchanged.

4.3.2. Overlapping coalitionsEach agentAi shall iteratively perform the following:

(i) Locate inLi the coalitionCj that has the smallest costcj .(ii) Announce the coalitional costcj that it has located.(iii) Choose the lowest among all of the announced coalitional costs. Thisclow will

be chosen by all agents. The corresponding coalitionClow and tasktlow shall beselected as well.

(iv) If you are a member of the chosen coalitionClow, join the other members ofClowand form the selected coalition.

(v) Erase fromT the task according to which the value of the newly-formedClow hasbeen calculated.

(vi) Update the capability vectors of all of the members ofClow according to theircontribution to the task execution.

(vii) Assign toLcri the coalitions inLi for which values should be re-calculated.

As in the case of disjoint coalitions, the iterative procedures of calculating coalitionalvalues and costs, selecting the preferred coalitions and forming them, will be repeated untilthere are no more tasks to be performed or none of the possible coalitions is beneficial.Here, some coalitional values must be re-calculated in every iteration because each valueis calculated with respect to the unused capabilities, and these may change due to theformation of a coalition. Note that in the disjoint case we use the coalitional weight whereasin the overlapping case we use the coalition cost. This difference is necessary since inthe disjoint case agents can only contribute once to the total outcome, therefore theirindividual weight is important, while in the overlapping case agents may contribute to the


total outcome several times, and therefore the contribution of whole coalitions is important.This difference causes a different choice of agents for the coalitions to be formed.

5. Tasks with precedence order

In a case where tasks have predecessors, each task can be satisfied only if all of itspredecessors have been performed previously. Hence, our precedence-order algorithmrequires that the choice of a task implies the choice of all of its predecessors (howeverit does not require that the same coalition will perform all the precedent tasks). For eachtask t , we denote its set of predecessors, includingt itself, by Pt . The choice oft forcoalition formation will depend on the costs of, and the benefits from, the formation ofcoalitions that performall of the tasks inPt .

In the original algorithms above, the agents form coalitions iteratively—one coalitionin each iteration. They greedily satisfy tasks, performing the single taskt that currentlyappears most beneficial. In the precedence-order case, the agents shall form severalcoalitions in each iteration, to perform all of the tasks in the specific setPt which appearsmost beneficial among all such possible sets. For the evaluation of these sets of tasks, weintroduce the concept of precedence valuepVt (p-value), which is the sum of the values ofall of the tasks in the precedence setPt .

As in the previous cases, where the value of a task was re-calculated in each iterationuntil it was chosen,pVt will be re-calculated in each iteration as well. Each suchcalculation ofpVt requires the calculation of the values of all of the tasks inPt . Forthis we employ the calculation methods of Sections 5.2 and 5.3, wherePt is substitutedinto T from 5.3. The internal precedence order withinPt is not considered as to this valuecalculation, since all of the tasks withinPt must be satisfied, ift is chosen. The distributionof the calculations among the agents will be performed as suggested in Section 5.2. In eachiteration, the bestpV is chosen from among all of the currentpV ’s. This implies that allof the tasks inPt will be satisfied as well. Since we introduced the notionPt , we mustemphasize its difference fromT , which denotes the set of all of the tasks that were not yetperformed. Initially,T includes all of the tasks that must be satisfied by the agent system.

The agents may either each perform all of the calculations concerning each taskt ∈ T , orthey may distribute these calculations, but in each step of the algorithm (when necessary)agree upon thePt to be calculated. Recall that only part of the values corresponding totasks inPt should be re-calculated.

All of the agents, simultaneously, should iteratively perform the following:– Given the current status of capabilities; for eacht ∈ T do:

(i) Compute greedily the values of all of the tasks inPt using the distributedmethods of Section 5.3, where the input set of tasks for the greedy calculationis Pt .

(ii) If, in step (i), all of the tasks inPt were assigned coalitions to perform them, thensetpVt to be the sum of the values of the tasks inPt .

(iii) Otherwise, removet from T . 22

22 This is sincet cannot be performed.


– Choose the taskt∗ with the maximalpVt to be performed together with all of itspredecessors. Form the required coalitions as in Section 5.3.

– Removet∗ and all of its predecessors fromT .– If an overlapping coalitions case, update the capability vectors of the associated

coalitions’ members. Else (disjoint coalitions), delete the members of the coalitionsfrom the list of candidates for coalition formation.

The above iterative procedure of calculating p-values and costs, selecting the preferredcoalitions for task execution and forming them will be repeated until there are no moretasks to be performed inT , or no more agents free to perform them. Note that as before, thevalues are dynamically changing as a result of the change in the accessibility of resources,and therefore shall be distributively re-calculated after each coalition formation.

6. Quality assessment

The algorithms presented above have several advantages. An important property of thealgorithms is their low logarithmic ratio bounds. Denote a coalition configuration byC, itstotal cost byctot=∑Cj∈C cj , and superscribe by∗ for the optimal case.

6.1. The overlapping case

To express the ratio bound by the same notions both for the disjoint and the overlappingalgorithms, we must define the agent weightwi for the case of the overlapping coalitions.Denote the number ofnew membersin a coalitionCi by zi ; the agent’s weight is theratio between the coalition costci andzi , i.e.,wi = ci/zi . Here, only agents who arenewmembers, i.e., agents who join a new coalition for the first time, are considered for weightcalculation (whereas in the disjoint case such a distinction is not necessary).

Theorem 1. The ratio boundρ of the algorithm for the overlapping case is given by

ρ = ctot

c∗tot6

max(|Cj |)∑i=1

1

i. (1)

Proof. Each coalitionCj contributes its costcj to the costctot of the coalition confi-gurationC of the solution. Since each agentAi receives some weightwi , ctot, which is thesum of the weights of all of the agents in the final coalitional configurationCfinal, is givenby:

ctot=∑Ai∈N

wi 6∑

Cj∈Cfinal

∑Ai∈Cj

wi. (2)

The inequality results from the fact that each agent contributes only once to the total cost(as expressed in the left side sum), and the right side sum allows multiple contributions bya single agent. For any final coalition configuration (and in particular for the optimal one):∑

Cj∈Cfinal

∑Ai∈Cj

wi 6∑

Cj∈Cfinal

∑Ai∈Cj

cj

|Cj | =∑

Cj∈Cfinal

cj∑Ai∈Cj

1

|Cj | . (3)


Since the following relation holds in general,

∑Cj∈Cfinal

cj∑Ai∈Cj

1

|Cj | 6∑

Cj∈Cfinal

cj

max(|Cj |)∑i=1

1

i= ctot

max(|Cj |)∑i=1

1

i(4)

it in particular holds forc∗tot, and the conclusion from (2), (3), and (4) is that

ctot6∑

Cj∈Cfinal

cj

|Cj |∑i=1

1

i6 c∗tot

max(|Cj |)∑i=1

1

i. (5)

Hence, we derive the ratio bound

ρ = ctot

c∗tot6

max(|Cj |)∑i=1

1

i. 2 (6)

Since the disjoint case algorithm is similar in its nature to the algorithm of theoverlapping case, the quality assessment is similar as well. Despite minor modificationsin its derivation, the ratio bound of the disjoint algorithm is similar, and therefore notpresented separately. Note that limn→∞

∑ni=1 1/i = γ + lnn, whereγ is Euler’s constant

(= 0.5772. . .). Therefore, this ratio bound grows logarithmically with the size of thecoalitions to which the algorithm refers. Since we previously suggested presenting aconstant to determine the maximum permitted coalitional size, we simultaneously limitedthe ratio bound to being a constant that can be calculated simply using (6). One must recallthat the ratio bound is the worst case bound.

6.2. The precedence-order case

As a result of the modified coalitional values, the costs and the weights are changed.

Proposition 2. The ratio bound in the precedence-order case is given by

ρ = ctot

c∗tot6 lnmax

(|Cj |) lnmax(|p-value|). (7)

Proof. The calculation of p-values in the precedence-order case is similar to thecalculation of values in both of the non-precedence-order cases. This is because thecalculations in all cases are based on the concept of choosing the lowest cost each timeand adding it to the total cost. Therefore, according to Theorem 1, the ratio bound of thep-value within any precedence setPt is

ρp-value= ctot(Pt )

c∗tot(Pt )6

max(|Cj∈Pt |)∑i=1

1

i6 lnmax

(|Cj ∈ Pt |). (8)

The total value is

ctot=∑pt⊆C

p-value (9)


and thereforectot is bounded byc∗tot lnmax(|p-value|). As a result, the ratio bound of thep-values contributes another logarithm into the ratio bound, thus yielding:

ρ = ctot

c∗tot6 lnmax

(|Cj |) lnmax(|p-value|). 2 (10)

7. Complexity of the algorithms

In addition to the quality of the solution with respect to the optimal solution (givenk), the efficiency of the algorithms should be judged from two main perspectives: that ofcomputations and that of communications. At the preliminary stage, where the calculationsare distributed, all of the relevant permutations of agents are calculated; this requires∑ki=1(n − 1)!/((n − i − 1)!i!) computation operations, which is of order O(nk−1) per

agent. During this stage the agents contact one another; each of them conducts up tonk−1/min(|Sij |) contacts with the other agents (where|Sij | is the size of the subsetof potential coalitions considered in each communication operation). Since the choiceof |Sij | may be any integer in the range[1,Cnk−2], the communication complexityvaries correspondingly. While in the best case (communication-wise), where|Sij | =Cnk−2(O(nk−2)), the average number of communication operations per agent is O(1), in theworst case, where|Sij | = 1, the communication complexity per agent at the calculations-distribution stage is O(nk−1).

Below we prove and discuss the complexity of the non-precedence case.

Proposition 3. For the value calculation and task assignment, the computational complex-ity per agent is of orderO(nk · |T |).

Proof. The value calculation process consists of the assignment of tasks to coalitions.23

Such an assignment is performed for all of the tasks, hence|T | assignments are necessary.The number of value calculation operations per agent is of order24 O(nk−1 · |T |). Giventhe assumption that the number of capabilities depends neither upon the number ofagents nor upon the number of tasks, each assignment operation requires O(1) operations.Choosing the largest value is of the order of the number of possible coalitions, i.e., O(nk−1)

computations per agent. The two processes of calculating coalitional values and choosingcoalitions may be repeated up ton times (however, if|T |< n, n will be replaced by|T |.Therefore, the computational complexity per agent is of order O(nk · |T |). 2

This complexity can be compared to a centralized case, where a single agent performsall of the operations. In such a case, this single agent will experience O(nk+1 · |T |)23 We assume that the planning for partitioning goals into sub-goals is given, and therefore the calculation of

coalitional values is not as complicated as in [42].24 Note that, while some agents perform O(nk−1 · |T |) value calculations, others may happen to perform less

than O(nk−1 · |T |) calculations. This property of the process is advantageous because it occurs when thereare differences in computational capabilities among the agents. In such cases the non-equal partition of thecalculations moderates the differences in the calculation time of the agents, thus reducing the average time ofcalculation completion.


computations and O(n) communications. Therefore, the computational complexity ishigher than in the average distributed case (the speed-up is of order O(n)), but thecommunicational complexity is lower.25 The overlapping coalitions’ case is similar tothe disjoint coalitions’ case. However, if|T |> n this case still allows for O(|T |) coalitionsto be formed, whereas in the disjoint casen is the upper limit.

Following we present the complexity of the precedence-order case. We do not providean explicit proof, however justify it informally.

Proposition 4. The computational complexity in the precedence-order case isO(nk · |T |5).

Proposition 4 is justified as follows. The change in the calculation of coalitionalvalues due to the precedence order yields an increase in the computational complexity. Inaddition to the original calculations, O(|T |3) operations are necessary for the calculationof each task’s p-value. This shall be performed up to|T | times, and therefore the overalladditional complexity is O(|T |4), by which the complexity of the original algorithm shallbe multiplied. Thus, the new complexity is O(nk · |T |5), which is a rough estimation ofits complexity. A deliberate analysis and the introduction of some heuristics reduce thecomplexity.

8. Simulation results

In order to strengthen the validity and to demonstrate the quality of our approach, wehave simulated the algorithm of overlapping coalitions with precedence order among thetasks. The simulation consists of a centralized program which calculates the task allocationand the coalition formation which would have resulted from the distributed algorithm. Thecentralization is aimed at simplifying both the code and the running process, however allof the properties of the original algorithm, except for its distribution, are kept. Separately,in the next section, we present a fully distributed implementation of the algorithm for adomain-specific agent system (with some modifications to the algorithm).

We are especially interested in the ratio between the total outcome of agent systemsthat act according to our algorithm and the optimal outcome of such systems. We are alsointerested in the number of tasks executed with respect to the number of tasks executedin the optimal case. Another important factor would be the run-time consumption withrespect to the number of agents and tasks.

The simulation system was tested for different ratios between the average amounts ofresources per agent and the average resource amount necessary for task execution, as weelaborate below. We have conducted several hundreds of runs of the simulation for variousnumbers of tasks, and the number of agents varying from 4 to 22. We have also performedfew simulations for 50 to 60 agents to check the functionality of the algorithm for largernumbers of agents and tasks. There were 4 different resources, randomly partitioned amongthe agents. As a result of this non-equal partition, agents could have amounts of some

25 If, for all agents, there exists a communication channel between every pair of agents, then the computationaloverhead of the distributed case will not affect the performance of the algorithm.


Fig. 1.

Fig. 2.

resources which are significantly different from the average. This affected their ability toperform tasks and has driven agents to coalition formation.

Figs. 1–6 present the results of the simulation, divided into three categories: Figs. 1and 2 present the results in the case where the average amount of resources per agent isapproximately equal to the average amount of resources necessary for each task execution;Figs. 3 and 4 present the results in the case where the average amount of resources peragent is significantly greater than the average amount of resources necessary for eachtask execution; Figs. 5 and 6 present the results in the case where the average amount of


Fig. 3.

Fig. 4.

resources per agent is significantly smaller than the average amount of resources necessaryfor each task execution. In each graph thex axis represents the ratio between the number ofagents and the number of tasks, and they axis represents the ratio between the simulationresults and the optimal results.26 Figs. 1, 3, 5 measure this ratio of task execution andFigs. 2, 4, 6 measure this ratio of the global system profits. In all six graphs, each square

26 We have computed an upper bound on the optimal results and not the optimal results themselves (due tocomplexity).


Fig. 5.

Fig. 6.

repersents the result of a single simulation (however some squares overlap due to similarresults of different experiments).

Via the simulations, we have examined the number of executed tasks with respect tothe number of tasks that would have been executed in the optimal case, given the samesettings (Figs. 1, 3, 5). In addition, we have tested the ratio between the profits gained bythe agents (as a result of task execution via coalition formation) and profits that would havebeen gained in the optimal case (Figs. 2, 4, 6). The results in both cases are very close tooptimal, as can be seen in the figures.


The main results of the simulations performed are as follows:(i) The ratio between the simulation task fulfillment and the optimal task fulfillment

is, in most cases, close to one, which means that the simulation task fulfillment isnear-optimal (Figs. 1, 3). Only when the ratio between the agents’ resources andthe tasks’ resources is significantly smaller than 1, does the task execution ratiodecrease (Fig. 5). Nevertheless, the profit ratio remains sub-optimal. The reason forthe decrement in the task fulfillment is that the algorithm leads to the choice of themost beneficial tasks. Thus, it may perform fewer tasks, yet reach a sub-optimalprofit.

(ii) The ratio between the profits from task execution via our algorithm and the optimalcase is close to one (Figs. 2, 4, 6). Note that this ratio is significantly better than thetheoretical ratio bound.

(iii) The run-time for all of the simulations was usually a few seconds (running on aSparc station) and always less than a minute, even when dealing with 50 to 60agents and tasks (and running on a PC).

(iv) During the simulation, coalitions of various sizes have formed.

9. Implementation in a dynamic, open MAS

In this section we report an implementation of the coalition formation methods pre-sented previously in a dynamic, open MAS. For this implementation we have chosen anexisting framework, the RETSINA agent system, which is a web-based system where tasksarrive dynamically to agents and agents may appear and disappear. A brief description ofthis system is provided below (the reader is referred to [52] for details). Implementing ouralgorithms in a RETSINA framework required some adjustments to the openness and dy-namism of the system, however proves the applicability and usefulness of these algorithmsto real-world MAS.

9.1. The multi-agent system

RETSINA (REusable Task-based System of Intelligent Networked Agents) [51–53] isa cooperative multi-agent system that was developed to integrate information gatheringfrom web-based sources and perform decision support tasks. The agents in RETSINAcompartmentalize specialized task knowledge, organize themselves to avoid processingbottlenecks, and can be constructed specifically to deal with dynamic changes in informa-tion, tasks, number of agents and their capabilities.

In RETSINA, the agents are distributed and run across different machines. Based onmodels of users, agents and tasks, the agents decide how to decompose tasks and whetherto pass them to others, what information is needed at each decision point, and when tocooperate with other agents. The agents communicate with each other to delegate tasks,request or provide information, find information sources, filter or integrate information,and negotiate to resolve inconsistencies in information and task models. The system con-sists of three classes of agents:interfaceagents,taskagents andinformationagents. Notethat a similar infrastructure is used in InfoSleuth [36]. Interface agents interact with users


receiving their specifications and delivering results. They acquire, model and utilize userpreferences. Task agents formulate plans and carry them out. They have knowledge of thetask domain, and which other types of task agents or information agents are relevant toperforming various parts of the task. In addition, task agents have strategies for resolvingconflicts and fusing information retrieved by information agents. They decompose plansand cooperate with appropriate task agents or information agents for plan execution, mon-itoring and results composition. Information agents provide intelligent access to a hetero-geneous collection of information sources. They have models of the information resourcesand strategies for source selection, information access, conflict resolution and informationfusion. Several typical tasks cannot be executed by a single agent and agents form teams,on demand, for such tasks.

For instance, suppose a user has requested an interface agent to monitor its investmentportfolio and maintain a given level of risk. The interface agent must involve in this taskinformation agents that can provide various types of information with regards to the assetsin the portfolio (e.g., price, relevant news). It also needs task agents that can analyze theinformation (e.g., compute risk) and critique it and make decisions and suggestions withregards to the portfolio. There may be several agents that can provide such services, and se-lecting the most appropriate ones is part of the coalition formation process. Note that theremay be multiple tasks arriving simultaneously at different agents in the system, thereforethere may be several attempts to form such coalitions. The coalition formation algorithmserves for this purpose.

A basic design problem of cooperative,open, multi-agent systems is the connectionproblem [13]. That is, each agent must be able to locate the other agents who might havecapabilities which are necessary for the execution of tasks, either locally or via coalitionformation. In an open system where participating agents may dynamically enter and leave,which is distributed over the Internet, broadcast communication solutions are precluded.The solution provided in RETSINA relies on some well-known agents and some basicinteractions with them—matchmaking [14,32]. In general, the process of matchmaking al-lows an agent with some tasks, the requester, to learn the contact information and capabil-ities of another agent, the server, who may be able to execute part of the requester’s tasksvia a matchmaker which is an agent that maintains the contact information, capabilities,and other service characteristics (e.g., cost, availability, reliability) of other agents.

During the operation of the multi-agent system, agents that join the system advertisethemselves and their capabilities to a matchmaker, and when they leave the agent society,they un-advertise (for more details, see [51]). In search of agents with which they maypossibly form coalitions, agents approach a matchmaker and ask for names of relevantagents. After having acquired the information about other agents they can directly contactthese agents and initiate cooperation as needed. Note that there may be several matchmakeragents to relax the problem of unavailable or overwhelmed single matchmaker and to avoida centralized solution.

9.2. Cooperation via coalition formation

The RETSINA system can receive several tasks from several users. Incorporation ofthe coalition formation mechanism increases the efficiency of groupwise task execution,


resulting in near-optimal task performance. We report such results in Section 9.3. Inaddition, this mechanism enables agents to decide upon the importance (and possibly—the order27) of tasks to be performed. Such decision making is important in real-worlddomains, where there may be situations in which a system cannot fulfill all of its tasks.A RETSINA agent considers cooperation if one of the following holds: the agent cannotperform a specific task by itself; the agent can perform a specific task, but other agents aremore efficient in performing this task (e.g., they require less resources or perform faster);the agent can perform a specific task, but working on it collaboratively will increase thebenefits from the task (or reduce the costs).

The implementation of the coalition formation mechanisms required that we modifythem due to several differences between the assumed agent systems and the RETSINAinfrastructure, as discussed below:

– The number of goals and agents assumed in previous sections is fixed, whileRETSINA is a dynamic system where agents appear and disappear and tasks varyconstantly.

– The method in which the information with regards to the existence of tasks and theirdetails is distributed is not discussed in the original algorithms.

To resolve the above restrictions, we made various modifications to the algorithms.28

We describe below how agents behave within the RETSINA framework when coalitionformation is applied, with the addition of the required modifications. Note that somefunctional issues of the RETSINA agents are described in an extremely simplified manner(elaborate details can be found in [51]). The activity of the system entails tasks whichdynamically arrive from users or agents. The activity of a single agent for each arrivingtask is as follows.

(i) When a tasktj arrives at agentAi (either from a user or from another agent) itperforms:(a) Addstj to Ti (its task list).(b) Finds possible decompositions oftj to subtaskst1j , . . . , t

lj using its tasks

reduction librarywhich includes pre-given possible decompositions.29

(c) According to the possible decompositions,Ai determines the capabilitiesneeded for performingtj (e.g., information gathering) and contacts a match-maker to find agents that have those capabilities and may be able to work onthe task. It adds these agents toNi (its agent list) and sends them each the rel-evant subtasks oftj (or the wholetj , if it is not decomposable). If the senderof tj toAi is an agent, it is added toNi as well.

(d) To avoid cyclic task delegation and to allow propagation of results back to therequester, the origin of the task (user or agent) as well as the delegation path

27 A RETSINA agent has an internal scheduling mechanism, but our algorithm provides priority generation,which is not part of the scheduler.28 Note, that the original algorithms do not discuss capability reuse and tasks with complex time dependencies,

such as partial overlapping use of a resource, which are typical in the RETSINA dynamic system. RETSINAagents take care of these even without the coalition formation (e.g., the agent’s scheduling resolves timedependencies). The implemented coalition formation algorithm inherits these properties.29 For example, checking whether a portfolio is balanced requires (at least) a subtask of finding the prices of

assets in the portfolio and a subtask of computing balance according to some criteria.


(i.e., the agents through which the task has passed) are added to each delegatedtask.

(ii) WhenAi ’s local schedule allows, it computes coalitions and their values and formscoalitions as follows:

(iii) Computing coalitions values: 30 for each tasktj in Ti it considers the possiblecoalitions that can be formed to perform it (based on its task reduction library)and computes the coalition value for each such possibility. The value calculationis performed by evaluating linear functions attached to each capability which takesinto account the typical amount of computational resources (e.g., cpu, memory, diskspace) necessary for such a task, as studied from past behavior of the RETSINAsystem and the time interval for execution.

(iv) Choosing Coalitions: 31

(a) Among the values computed in step (iii),Ai chooses the one with the highestvalue (correspondingly, the lowest costcj ), denotes itCj , and registersCjand its value at the matchmaker.

(b) Ai checks whether the value it registered is the highest registered at thematchmaker. If so it forms with the members ofCj the coalition and performsthe associated task and subtasks. If no other values are registeredAi re-checksfor values after a waiting period.32

(c) Upon completion (on which the members of the coalition report toAi), Airemovestj from Ti . In case of task execution failure (and iftj ’s deadlinehas not passed)tj is kept in the list for future handling. Note that updates tocapabilities are performed individually by agents at their matchmaker.

(d) Concurrently, ifTi is not empty,Ai performs (as its local schedule allows)occasional polling of the matchmaker for changes in coalitions, values, agentavailability, and continually performs the coalition formation algorithm byskipping to step (ii) (and possibly being a member of several coalitions).

In RETSINA the communication and computation time for value calculation andcoalition design are significantly small as compared to the task execution time and taskscan dynamically appear. Therefore, the modified algorithm includes a re-design process.When a new task is received by an agent, we require:

– If tasks that were assigned to coalitions have not been performed yet within the currentiteration of the coalition formation algorithm, agents who are in these coalitions andare informed about the new task will re-calculate the coalitional values to take intoconsideration the arrival of the new task:• if inclusion of the newly arrived task in coalition recalculations in the current

iteration introduces a new coalition value, greater than currently known values,

30 This step corresponds to the algorithm in Section 4.2. However, while in the original algorithm tasks areassociated with coalitions, here coalitions are associated with tasks. That is, for each task the best coalition isfound. This is simpler to implement in an open system, where tasks are not known to all agents.31 This step corresponds to the algorithm in Section 4.3.32 Such situations may occur due to asynchrony in the system as well as differences in agent computation time

and network latency. Waiting for additional values may be beneficial if the task’s deadline allows.


then the agents re-design the coalitions, selecting again the best among the actual,re-designed, coalitions;33

• otherwise, the agents avoid coalition re-design, and consider the new task forinclusion in coalitions at the next iteration.

– If all previous tasks are in process, the new task, has it arrived atAi , will be added tothe group of tasksTi and be dealt with in the next coalition formation iteration.

– In case of a rapid high-frequency stream of new tasks, the re-design process maybe dis-enabled. If such a rate of new tasks is expected in advance, or the agentsstatistically infer such a rate by sampling the task stream and interpolating thestatistical data, the re-design process shall be avoided.

9.3. Analysis of the modifications

The dynamic addition of tasks to the agent system may change the overall order ofcomplexity of the algorithm. In the worst case, the re-design process will be performed forevery new task. This will result in performing the whole process|Td | times, where|Td |is the number of dynamically received tasks. Therefore, the original complexity analysisshould be multiplied by|Td |. SinceTd ⊆ T , the re-design process implies an increase incomplexity by an order of magnitude with respect to the number of tasks.

The communication requirements of the original algorithms are, in the worst case, ratherlarge. We designed the implemented algorithm to avoid the worst case of communicationcomplexity. This was performed by the requirement that on each contact ofAi withAj it implicitly commits to compute the maximalSij . This results in a communicationcomplexity for commitment which is O(n · Td) per agent (however the average is O(Td)).In the modified algorithm the communication complexity in the value calculation andtask assignment stages is similar to the original (i.e., O(n · |T |) per agent). However,additional communication is required for informing other agents about dynamicallyarriving tasks. Therefore, while the worst case remains unchanged, the average casebecomes O(|Td | · n). Yet this is a low linear complexity. Nevertheless, in web informationgathering (in which RETSINA operates), the network latency causes the computation timefor coalition formation to be dwarfed by comparison. This was observed in the course ofour experiments.

Originally, the number of agentsn was assumed to be constant. However, in RETSINA,n may dynamically change, hence the complexity analysis is slightly modified. Letν = max(n), where this maximum may be decided upon by designers according to theirexpectations with regards to the agent system. Then, substituten in the original complexityexpression byν, resulting in O(νk−1 · |T | · |Td |).

RETSINA agents are able to perform task reductions [60]. In practice, the internalcomplexity of a subtask is determined within the task reduction and task schema libraries(in general, these libraries provide details for planning and executing tasks). The librariesare domain-specific, hence the designers of the domain-specific components have controlover the complexity of subtasks. In the information domain of RETSINA subtasks, each

33 Note that re-design may not be allowed if the expected task flow is rapid, lest the system will constantlyre-design and not perform its tasks.


subtask can typically be performed by a small number of agents. This implies that thecoalition formation procedure will concentrate on the formation of small coalitions ofagents with particular expertise to perform a task.

For example, one of the domains in which RETSINA was implemented is satellitetracking. One of the tasks that the agents can cooperatively perform is finding if and whena specific satellite will be observable in a specific location. For this, up to 4 informationagents are involved in the information gathering, and up to 4 other agents are involved inother related tasks. This means that the maximal coalition size for this task type is 8. Sinceother tasks of the system are of the same order of complexity, the sizes of coalitions arelimited as well. The system may include other active agents, however these will be involvedin other tasks or be idle.

The specialization of agents in RETSINA results in the incorporation of agents intocoalitions according to their specialty/capability (when more than one agent with the samespecialty are present, their utility functions enables comparison which results in the choiceof the one with the highest payoff). Thus, a coalition size is limited to the number ofdifferent specialties which are necessary for the execution of the task that this coalitionperforms. In current RETSINA implementations, the number of specialties which arenecessary for a given task execution is small and hence such is also the size of coalitions.The maximal number of specialties necessary for subtask execution complies with thek

restriction on the size of coalitions. However, since different decompositions of tasks alongdifferent specialty dimensions are possible, a specific agent system may have severalk’s.Among them, the maximal will determine the worst case complexity.

9.4. Implementation settings

To apply the modified coalition formation algorithm to a RETSINA framework wehad to simulate some of the RETSINA properties, while maintaining its openness anddistribution as well as interaction mechanisms, including matchmaking and advertisement.This was performed by running degenerated RETSINA agents that were able to register at amatchmaker and query it for other agents, and could receive tasks as RETSINA agents do.The degenerated agents did not perform the tasks but only simulated the task performance.However, the simulated computational resources availability and consumption in thesimulated task performance were similar to these values in the original system, as studiedfrom the performance of RETSINA.

The implementation was performed by running up to 20 agents on several machines,and a stream of tasks was supplied to the agents, totalling to 1000 tasks. Each agentwas represented by an agent thread that simulated the resource consumption and thetask queue of a real agent. The agents were running on several Sun workstations. Eachagent-thread received an initial set of tasks, and additional tasks arrived at each agentdynamically in a random manner (i.e., the frequency of tasks, their type and the requiredcapabilities were chosen in a random manner, according to the typical distributions asstudied from RETSINA). Each task was associated with a vector of capabilities necessaryfor its execution and a payoff function for calculating the value of the task. For each task theagent creates a task object that consumes time and memory and requires communication.The agent informs other agents about these tasks by passing references to task objects.


Fig. 7. The average performance (solid line) and the worst case (broken line), expressed as a fraction of theoptimal performance, as a function of the maximal coalition size permittedk.

The CPU, communication and memory consumption are similar to those consumed byRETSINA agents. This resource consumption was previously measured as presented in[47].

During the simulation, coalitions of agents were formed, where a task was allocated toeach, and the value of its execution by this coalition was calculated. The sum of these valueswas calculated to find the total payoff. When new tasks arrived, the re-design procedure wasfollowed. We have performed this simulation several hundreds of times, and compared thetotal payoffs to the optimal payoffs (calculated off-line) and to the theoretical ratio bound,as depicted above.

In Section 6 we have shown that the ratio bound increases logarithmically with respect tothe number of coalition members. However, by implementing the algorithm in a simulatedRETSINA agent system we show that the average case (for this specific domain) is closeto the optimal case (see Fig. 7). The figure shows that the average performance (in termsof task allocation and execution) reached in the simulated RETSINA agents, depictedby the solid line, is around 0.9 of the optimal performance,34 while the worst case (theratio bound), depicted by the broken line, declines fast to less than 0.5 of the optimalperformance. Note that although in this implementation the asynchrony of the systemprohibits the choice of the best value each time (instead, the best currently known value isselected), we still get near-optimal results.

10. Related work

Distributed task allocation has been discussed in the context of DPS systems. A well-known example of such a task allocation mechanism is the Contract Net Protocol

34 We calculated the optimal performance explicitly, off line, when a small number of agents are involved incoalition formation. Small here means up to 20.


(CNP) [49]. The CNP discusses cases in which an agent that attempts to satisfy atask may divide it into several subtasks and then sub-contract each subtask to anotheragent via a bidding mechanism. In the CNP, tasks are allocated to single agentsand a procedure for task partitioning is necessary. The CNP allows single agents toperform more than one subtask. This is similar to our approach as we, too, allowthat agents be involved in the performance of more than one task in some of ouralgorithms. However, we do not deal with the case of single agents. Rather, we solvethe problem of assigning tasks to groups of agents. In cases where single agentscannot perform tasks by themselves and tasks cannot be partitioned, or the partition iscomputationally too complex, close cooperation (within coalitions) is required. In the CNPthe efficiency of the solution was evaluated through simulations. However, since the issueof efficiency and complexity is crucial for the implementation of a solution, we providea formal analysis of the quality and the complexity of our solutions, in addition to asimulation.

The allocation of tasks to teams of agents in order that they perform these tasks wasdiscussed by several DAI researchers, e.g., [25,38,55]. Although discussing the assignmentof roles to groups of agents, the process of designing and forming these groups, and theemphasis on seeking near-optimal performance, are not addressed there. Jennings [25]presents a system that handles task allocation by having a central organizer that usesinformation it has about the abilities of all other agents to assign tasks. Recipe selectionfor the complex group action is also managed by this central organizer. The team membersselect their own recipes for the single-agent constituent actions; there is no descriptionof the mechanism according to which agents will form teams. In addition, the solutionrequires a central agent. Both of these limitations are avoided in our solution. Jenningsdiscusses the joint intentions and the shared plans, whereas such planning issues are beyondthe scope of our research.

As mentioned in the introduction, one can find two main extreme approaches in DAI:one is Distributed Problem Solving (DPS), which is concerned with cases where a groupof agents faces satisfaction of a common task. DPS deals with the ways in which theagents distribute the task among them and individually or cooperatively fulfill the resultingsubtasks [15,17,48]; the other extreme is Multi-Agent Systems (MAS), which focuses onsystems of autonomous agents who are self-motivated and act in order to achieve theirown personal tasks and increase their own personal utility. However, DPS and MAS arethe two extremes in a variety of multi-agent situations lying between those two confines.In our paper we deal with autonomous agents’ systems which are closer to the DPStype, although they may be acting as individuals and who try, under certain restrictionsof the system, to increase their own benefits. Cooperation among autonomous agentsmay be mutually beneficial even if the agents are selfish and try to maximize their ownexpected utilities [30,50,63], as they do in MAS. In the case of DPS, the benefits ofcooperation may be even greater than in the MAS case, since competition among the agentsis restricted. In both cases, benefits may arise from cooperation via resource sharing andtask redistribution.

DAI research has previously addressed the problem of tasks with precedence orderand of overlapping problem solvers, as in [16]. There, coordination is based on anorganizational view of node activity, where each node acts subject to its local control,


solving a sub-goal of the global goal. The organizational view implicitly resembles theidea of a coalition. However, Durfee et al. do not discuss coalitions nor do they address theproblem of forming groups of nodes to improve the overall performance of goals.

Coalition formation is an important method of cooperation in multi-agent environments.Game theory provides an analysis of the possible coalitions that shall form as a resultof a coalition formation process, and the resulting disbursements to the agents, assumingthat agents do not have multiple memberships in coalitions. For example, see [18,27,40,61]. However, game theory does not provide algorithms which agents can use in order toform coalitions. Given a previously formed coalitional configuration (that is, a partitionof the agents to subsets), game theory usually concentrates on checking its stability orits fairness35 and on the calculation of the corresponding payments. Game theory rarelytakes into consideration the special properties of a multi-agent environment. That is,the communication costs and limited computation time are seldom considered, and thesolutions are not distributed. In our case, we are particularly interested in the coalitionformation mechanism and how to distribute it among the agents. We also seek a dynamicevaluation of the coalitions36 where game theory usually provides a static evaluation, andwe allow agents to be members of more than one coalition. Therefore, the game-theoreticcoalition formation theories are not appropriate for the multi-agent situation with whichwe are concerned.

Sandholm and Lesser [42] present a coalition formation model for bounded-rationalagents and a general classification of coalition games. As in [42], we also allow forvarying coalitional values. In [42], the value of a coalition depends on the computationtime. However, we consider cases in which the time for computing the coalition values ispolynomial, and the values vary with respect to the resource consumption by previously-formed coalitions. The model presented by Sandholm and Lesser refers to a non-restrictednumber of configurations, whereas we present greedy algorithms that bound the number ofconfigurations to be considered.

The problem of coalition formation can be approached as a Set Partitioning Problem(SPP). Coalition formation where coalitions may overlap can be approached as a SetCovering Problem (SCP).37 Set partitioning entails the partition of a set into subsets,and the set partitioning problem is finding a partition with the least cost. Since coalitionformation of agents results in the partition of the agents into subgroups, SPP and SCPmay be appropriate for determining which coalitions will form as a result of coalitionformation algorithms. The SPP and the SCP have been dealt with widely in the contextof NP-hard problems [19]. Exact solutions and approximations to SPP and SCP havebeen proposed in the fields of operations research, combinatorial algorithms, and graphtheory [3,4,8,9,20]. However, the solutions that have been proposed do not provide anappropriate solution to the problem of coalition formation among agents, due to threemain deficiencies: (1) The exact and optimal solutions are solutions for NP-hard problems.That is, the complexity of the solution is exponential in the number of agents. Such a

35 Stability and fairness have several different definitions in the context of game theory.36 The values of the coalitions change dynamically due to rapid changes in the tasks and resource availability,

and therefore relying on the initial values is misleading.37 The SCP, which is very similar to the SPP. Both are described in in detail in Section 3.2.


solution cannot be applied in cases where there are many agents in the environment, sincethe agents will be unable to calculate it. (2) The approximation algorithms, which leadto near-optimal solutions38 are of polynomial complexity, but they deal with a tightlyrestricted number of pre-defined possible subgroups of a given set. This may be overlyrestrictive for the case of agent coalition formation, where there are 2n subsets of agiven set ofn agents. This limitation may be resolved by artificially limiting the possiblecoalitions (as we do in our solution). (3) All of the present solutions are centralized.That is, the solutions can be calculated and implemented only by a central agent whichdominates the coalition formation process and supervises the other agents. Such a situationis not typical in distributed agents’ environments, and is inappropriate for our case,since it may result in a single point of failure as well as a computational bottleneck.In contrast MAS, among other goals, aim at reducing such problems and increasingrobustness.

Distributed computing systems (DCS) research has dealt with problems of taskallocation with precedence order. Optimal solutions were provided only for stronglyconstrained cases of two-processor systems (e.g., [10]). Sub-optimal solutions were alsopresented (see, e.g., [24]), yet these are constrained as well. The general problem isNP-complete, but some approximation algorithms [57] provide good solutions for themulti-processor system. In [7] an algorithm for such a task assignment was presented.The proposed solution is aimed at reducing the task turnaround time. The minimizationof the task turnaround time is the main objective of task assignment within distributedcomputing systems. In our work, the main issue is the development of a task allocationthat will increase the benefits of the agent system, and not necessarily reduce the executiontime. While DCS research usually discusses a fully-connected multi-processor system, weassume only a multi-agent system in which agents try to maximize the outcome of thesystem as a whole. Agents may be of various types, belong to different owners, be locatedin remote places and be indirectly connected. We discuss the specific case where singleagents cannot perform the tasks alone, and they must join together in order to do so.

Research on the Loading Time Scheduling Problem (LTSP) [5] presents approximationalgorithms for precedence-ordered task execution in cases where tasks may be performedeither by a single machine or by several machines, but each task can be performed onlyby a subset of the machines. This appears to be similar to our research however, thereare several differences, as follows: (i) our research concentrates on cases in which partof the tasks can only be performed by groups of agents and not by single agents; (ii)the main factor in the LTSP is the loading time of the first task in a sequence of taskson a specific machine, while we discuss neither the loading time nor the effect of task-sequences on a single agent; (iii) we discuss the utility that arises from task executiongiven the precedence order and subject to the resource distribution among the agents. Thedifferences of our case from the DCS research requires another approach, as presentedabove.

38 Near-optimal solutions are such that the ratio between them and the optimal solution is not large. In our casethe available solutions have such a ratio for a small number of agents, but this ratio is growing logarithmicallywith in number of agents.


A study of planning in MAS has been presented by Wellman [58]. In this research,the general-equilibrium approach from economics serves as the theoretical basis for theplanning mechanism. Mechanisms in which competition is applied are used to constructa market-oriented programming environment, which is employed as a means for the con-struction and analysis of distributed planning systems. In his research, Wellman concen-trates on competitive agents whereas we discuss cooperative agents. In addition, the forma-tion of coalitions is not addressed there. The theoretic model underlying market-orientedprogramming is more suitable for large-scale systems of agents, although under some re-striction may provide good results even for small number of agents, as proved by simula-tions in [34].

A market-oriented approach was also utilized for task allocation, as presented in [56].There, Walsh and Wellman present a simple auctioning protocol for the pricing and alloca-tion of tasks among self-interested agents. In contrast, we address the case of cooperativeagents. As a result, while Walsh can only prove convergence to a solution, we can, inaddition, prove to that our protocols lead to near-optimal solutions. One important issuewhich is not addressed by Walsh and Wellman is the effects of the formation of groupsagents. Such groups may allow for executing tasks which single agents cannot perform.Task execution by groups may also increase the efficiency of the execution. These have amajor effect on the overall benefits of the agent system, hence we focus on groups (in ourterms—coalitions) in our work.

Hard computational problems, including the class of NP-complete problems, are ad-dressed Huberman et al. in [23]. This research suggests, instead of employing a singleapproximation algorithm, using a portfolio of such algorithms where the algorithms areperformed interleavingly. As proved in that research, such an approach may result in a so-lution that is preferable to any of the single component algorithm results. As the authorsstate, this economics-based approach can be used for the distribution of computational re-sources thus increase the efficiency of task performance. This might have been useful toaddress the problems discussed here, however no method is provided for distribution of theproposed approach and, more importantly, the issue of forming groups of agents as a meansof increasing performance is not the goal of Huberman et al., therefore not addressed inthat research.

Cooperation among agents for the solution of complex optimization problems isdiscussed in [54]. There, a team of multiple asynchronous programs (A-Team) workscooperatively to solve a problem. Although A-Teams improve upon other imperfectalgorithms, the cooperation among the team members is very simplistic, as it refers to “non-zero intersection of output-space” of the cooperating agents. According to this approach,it is sufficient for the agents in an A-Team to have some common information with respectto the tasks or their solutions to claim cooperation among them. We refer to cases in whicha higher level of cooperation is applied and these allows not only for improvement insolutions, but near-optimality. In addition, we deal with the formation of multiple groupsof cooperating agents, not a single team. One interesting property of A-Teams is theirscale-effectiveness, that is, the performance is better for greater teams. As opposed, weconsider a comparatively small number of agents. This A-Team property is similar to themarket-based systems as described above.


11. Discussion

In this paper we presented algorithms for task allocation among computational agentsvia coalition formation in a non-super-additive environment. The algorithms are suitablefor cases where agents are motivated to act in order to maximize the benefits of the systemas a whole. They are most appropriate for the incidents in which the agents cannot performthe tasks by themselves. However, they may also improve the efficiency of task executionwhen the performance of single agents is worse than their performance within groups. Thealgorithms are adjusted to cases in which the tasks have a precedence order as well, andstill yield sub-optimal results.

Although general task allocation problems are computationally exponential (they are atleast NP-complete), we present polynomial-complexity algorithms that yield results whichare close to the optimal results and, as we have proven, are bounded by a logarithmic ratiobound. Our distribution method prevents most of the possibly overlapping calculations,thus saving unnecessary computational operations and leads to an even distribution ofcomputation that takes into account the individual computational capabilities of the agents.In addition, the distribution of calculations is an outcome of the algorithm characteristics,since each agent performs primarily those calculations that are required for its own actionsduring the process. In cases with no precedence order, this distribution method preventsmost of the calculations that may have been repeated by individual agents, thus savingunnecessary computational operations. However, this last property is less significant in thecase of precedence-ordered tasks.

The algorithms are any-time algorithms. If halted before normally terminated, they stillprovide the system with several coalitions that have already formed and task allocated tothem. In the non-precedence case the results, when halting, are of good quality. In theprecedence-order case, better subgroups of tasks and coalitions are formed prior to others.However, if the algorithm is halted before the performance of such a subgroup has beencompleted, the accumulative value of the tasks within the subgroup is not necessarily thebest. This means that although the any-time property of the algorithm exists for both cases,the case of precedence order may yield less beneficial intervention results. The any-timeproperty of an algorithm is important for dynamic environments, wherein the time periodfor negotiation and coalition formation processes may be changed during the process.

The coalition formation methods were implemented in a real-world, information multi-agent system, to improve multi-agent cooperation (in terms of the joint payoff). To enablethe implementation we had to relax several binding assumptions and limitations, takinginto account requirements and constraints arising from the dynamism and openness of thesystem. We have shown that the incorporation of the coalition formation method induces anear-optimal task allocation while not significantly increasing the execution time.

To summarize, the algorithms presented in this paper can be used for task allocationand execution in dynamic, open systems of distributed computational agents, as we havedemonstrated. They are not a general solution to the distributed task allocation problem.Some restrictive assumptions do apply. Nevertheless, the algorithms are appropriate forseveral realistic cases, where tasks may have a precedence order due to interdependenciesand where agents can be involved in the performance of more than one task. The algorithmsmay be used in distributed cooperative agent systems (in which tasks shall be assigned to


agents in order that the agents will perform them) to maximize the expected outcome ofthe system as a whole and minimize the computational overhead.

References

[1] R.J. Aumann, The core of a cooperative game without side-payments, Trans. Amer. Math. Soc. 98 (1961)539–552.

[2] R.J. Aumann and B. Peleg, Von Neumann–Morgenstern solutions to cooperative games without side-payments, Bull. Amer. Math. Soc. 66 (1960) 173–179.

[3] E. Balas and M. Padberg, On the set covering problem, Oper. Res. 20 (1972) 1152–1161.[4] E. Balas and M. Padberg, On the set covering problem: An algorithm for set partitioning, Oper. Res. 23

(1975) 74–90.[5] R. Bhatia, S. Khuller and J. Naor, The loading time scheduling problem, in: Proceedings 36th Annual IEEE

Symposium on Foundations of Computer Science (FOCS-95), 1995, pp. 72–81.[6] A.H. Bond and L. Gasser, An analysis of problems and research in DAI, in: A.H. Bond and L. Gasser (Eds.),

Readings in Distributed Artificial Intelligence, Morgan Kaufmann, San Mateo, CA, 1988, pp. 3–35.[7] G.H. Chen and J.S. Yur, A branch-and-bound-with-underestimates algorithm for the task assignment

problem with precedence constraint, in: Proceedings 10th International Conference on DistributedComputing Systems, 1990, pp. 494–501.

[8] N. Christofides and S. Korman, A computational survey of methods for the set covering problem, Math.Oper. Res. 21 (5) (1975) 591–599.

[9] V. Chvatal, A greedy heuristic for the set-covering problem, Math. Oper. Res. 4 (3) (1979) 233–235.[10] E.G. Coffman and L.R. Graham, Optimal scheduling for two-processor systems, Acta Informatica 1 (1972)

200–213.[11] R. Conte, M. Miceli and C. Castelfranchi, Limits and levels of cooperation: disentangling various types

of prosocial interaction, in: Y. Demazeau and J.P. Muller (Eds.), Decentralized A.I., Vol. 2, Elsevier,Amsterdam, 1991, pp. 147–157.

[12] T.H. Cormen, C.E. Leiserson and R.L. Rivest, Introduction to Algorithms, MIT Press, Cambridge, MA,1990.

[13] R. Davis and R.G. Smith, Negotiation as a metaphor for distributed problem solving, Artificial Intelligence20 (1) (1983) 63–109.

[14] K. Decker, K. Sycara and M. Williamson, Middle-agents for the internet, in: Proceedings IJCAI-97, Nagoya,Japan, 1997, pp. 578–583.

[15] E.H. Durfee and V.R. Lesser, Negotiating task decomposition and allocation using partial global planning,in: L. Gasser and M.N. Huhns (Eds.), Distributed Artificial Intelligence, Vol. II, Pitman/Morgan Kaufmann,London, UK, 1989, pp. 229–244.

[16] E.H. Durfee, V.R. Lesser and D.D. Corkill, Coherent cooperation among communicating problem solvers,in: A.H. Bond and L. Gasser (Eds.), Readings in Distributed Artificial Intelligence, Morgan Kaufmann, SanMateo, CA, 1988, pp. 268–284.

[17] E.H. Durfee and V.R. Lesser, Global plans to coordinate distributed problem solvers, in: Proceedings IJCAI-87, Milan, Italy, 1987, pp. 875–883.

[18] D. Fudenberg and J. Tirole, Game Theory, MIT Press, Cambridge, MA, 1991.[19] M.R. Garey and D.S. Johnson, Computers and Intractability: A Guide to the Theory of NP-completeness,

W.H. Freeman, San Francisco, CA, 1979.[20] R.S. Garfinkel and G.L. Nemhouser, The set-partitioning problem: set covering with equality constraints,

Oper. Res. 17 (1969) 848–856.[21] J.C. Harsanyi, A simplified bargaining model forn-person cooperative game, Internat. Economic Review 4

(1963) 194–220.[22] J.C. Harsanyi, Rational Behavior and Bargaining Equilibrium in Games and Social Situations, Cambridge

University Press, 1977.[23] B.A. Huberman, R.M. Lukose and T. Hogg, An economic approach to hard computational problems, Science

275 (1997) 51–54.


[24] O.H. Ibarra and C.E. Kim, On two-processor scheduling of one- or two-unit time tasks with precedenceconstraints, J. Cybernetics 5 (3) (1976) 87–109.

[25] N.R. Jennings, Controlling cooperative problem solving in industrial multi-agent systems using jointintentions, Artificial Intelligence 75 (2) (1995) 1–46.

[26] S. Jha, O. Shehory and K. Sycara, Viewing contingent contracts between agents as options, Unpublishedmanuscript.

[27] J.P. Kahan and A. Rapoport, Theories of Coalition Formation, Lawrence Erlbaum Associates, Hillsdale, NJ,1984.

[28] S.P. Ketchpel, Forming coalitions in the face of uncertain rewards, in: Proceedings AAAI-94, Seattle, WA,1994, pp. 414–419.

[29] S. Kraus, An overview of incentive contracting, Artificial Intelligence 83 (2) (1996) 297–346.[30] S. Kraus, J. Wilkenfeld and G. Zlotkin, Multiagent negotiation under time constraints, Artificial Intelligence

75 (2) (1995) 297–345.[31] T. Kreifelts and F. Von Martial, A negotiation framework for autonomous agents, in: Proceedings Second

European Workshop on Modeling Autonomous Agents in a Multi-Agent World, 1990, pp. 169–182.[32] D. Kuokka and L. Harada, On using KQML for matchmaking, in: Proceedings First International Conference

on Multi-Agent Systems, AAAI Press, San Francisco, CA, 1995, pp. 239–245.[33] R.D. Luce and H. Raiffa, Games and Decisions, John Wiley, New York, 1957.[34] T. Mullen and M. Wellman, A simple computational market for network information services, in:

Proceedings First International Conference on Multiagent Systems, AAAI Press, San Francisco, CA, 1995,pp. 283–289.

[35] B. Nadel, Constraint satisfaction algorithms, Comput. Intell. 5 (1989) 188–224.[36] M. Nodine and A. Unruh, Facilitating open communication in agent systems: the infosleuth infrastructure,

in: M. Singh, A. Rao and M. Wooldridge (Eds.), Intelligent Agents 4, Lecture Notes in Artif. Intell., Vol.1365, Springer, Berlin, 1997, pp. 281–296.

[37] P. Prosser, Hybrid algorithms for the constraint satisfaction problem, Comput. Intell. 9 (1993) 268–299.[38] A.S. Rao, M.P. Georgeff and E.A. Sonenberg, Social plans: a preliminary report, in: Decentralized Artificial

Intelligence, Vol. 3, Elsevier, Amsterdam, 1992, pp. 57–76.[39] A. Rapoport,N -Person Game Theory, University of Michigan Press, Ann Arbor, MI, 1970.[40] E. Rasmusen, Games and Information, Basil Blackwell, Cambridge, MA, 1989.[41] T.W. Sandholm, An implementation of the contract net protocol based on marginal cost calculations, in:

Proceedings AAAI-93, Washington, DC, 1993, pp. 256–262.[42] T.W. Sandholm and V.R. Lesser, Coalitions among computationally bounded agents, Artificial Intelligence

94 (1997) 99–137.[43] L.S. Shapley, A value forn-person game, in: H.W. Kuhn and A.W. Tucker (Eds.), Contributions to the

Theory of Games, Princeton University Press, 1953.[44] O. Shehory and S. Kraus, Coalition formation among autonomous agents: strategies and complexity, in:

C. Castelfranchi and J.P. Muller (Eds.), From Reaction to Cognition, Lecture Notes in Artif. Intell., Vol.957, Springer, Berlin, 1993, pp. 57–72.

[45] O. Shehory and S. Kraus, Task allocation via coalition formation among autonomous agents, in: ProceedingsIJCAI-95, Montréal, Que., 1995, pp. 655–661.

[46] O. Shehory and S. Kraus, Formation of overlapping coalitions for precedence-ordered task-execution amongautonomous agents, in: Proceedings ICMAS-96, Kyoto, Japan, 1996, pp. 330–337.

[47] O. Shehory, K. Sycara and S. Jha, Multi-agent coordination through coalition formation, in: M. Singh,A. Rao and M. Wooldridge (Eds.), Intelligent Agents 4, Lecture Notes in Artif. Intell., Vol. 1365, Springer,Berlin, 1997, pp. 143–154.

[48] R.G. Smith, A framework for distributed problem solving, in: Proceedings IJCAI-79, Tokyo, 1979, pp. 836–841.

[49] R.G. Smith, The contract net protocol: high-level communication and control in a distributed problem solver,IEEE Trans. Comput. 29 (12) (1980) 1104–1113.

[50] K. Sycara, Persuasive argumentation in negotiation, Theory and Decision 28 (1990) 203–242.[51] K. Sycara, K. Decker, A. Pannu and M. Williamson, Designing behaviors for information agents, in:

Proceeding Agents-97, Los Angeles, CA, 1997, pp. 404–412.


[52] K. Sycara, K. Decker, A. Pannu, M. Williamson and D. Zeng, Distributed intelligent agents, IEEE Expert –Intelligent Systems and Their Applications 11 (6) (1996) 36–45.

[53] K. Sycara and D. Zeng, Coordination of multiple intelligent software agents, Internat. J. Intelligent andCooperative Information Systems 5 (2–3) (1996) 181–211.

[54] S.N. Talukdar, L. Baerentzen, A. Gove and P.S. deSouza, Asynchronous teams: cooperation schemesfor autonomous, computer-based agents, Technical Report EDRC-18-59-96, Carnegie Mellon University,Engineering Design Research Center, Pittsburgh, PA, 1996.

[55] G. Tidhar, A.S. Rao and E.A. Sonenberg, Guided team selection, in: Proceedings ICMAS-96, Kyoto, Japan,1996, pp. 369–376.

[56] W.E. Walsh and M.P. Wellman, A market protocol for distributed task allocation, in: Proceedings ICMAS-98, Paris, France, 1998.

[57] L. Wang and W. Tsai, Optimal assignment of task modules with precedence for distributed processing bygraph matching and state-space search, BIT 28 (1988) 54–68.

[58] M.P. Wellman, A market-oriented programming environment and its application to distributed multicom-modity flow problems, J. Artif. Intell. Res. 1 (1993) 1–23.

[59] E. Werner, Toward a theory of communication and cooperation for multiagent planning, in: ProceedingsSecond Conference on Theoretical Aspects of Reasoning about Knowledge, Pacific Grove, CA, 1988,pp. 129–143.

[60] M. Williamson, K. Decker and K. Sycara, Unified information and control flow in hierarchical task networks,in: Proceedings AAAI-96 Workshop on Theories of Planning, Action, and Control, Portland, OR, 1996.

[61] L. Zhou, A new bargaining set of ann-person game and endogenous coalition formation, Games andEconomic Behavior 6 (1994) 512–526.

[62] G. Zlotkin and J. Rosenschein, Negotiation and task sharing among autonomous agents in cooperativedomain, in: Proceedings IJCAI-89, Detroit, MI, 1989, pp. 912–917.

[63] G. Zlotkin and J. Rosenschein, Cooperation and conflict resolution via negotiation among autonomousagents in noncooperative domains, IEEE Trans. Systems, Man Cybernetics, Special Issue on DistributedArtificial Intelligence 21 (6) (1991) 1317–1324.

[64] G. Zlotkin and J. Rosenschein, Coalition, cryptography, and stability: mechanisms for coalition formationin task oriented domains, in: Proceedings AAAI-94, Seattle, WA, 1994, pp. 432–437.

methods for task allocation via agent coalition formationferber/m2r/biblio/ai1548.pdf ·...

Documents