From: Proceedings of the First International Conference on Multiagent Systems. Copyright © 1995, AAAI (www.aaai.org). All rights reserved.
Designing a Familyof CoordinationAlgorithms*
Keith S. Decker and Victor R. Lesser
Departmentof ComputerScience
University of Massachusetts
DECKER@CS.UMASS.EDU
Abstract
Many
researchershaveshown
that there is nosinglebest organization or coordinationmechanism
for al[ environments.
This
paperdiscussesthe designandimplementation
of an extendable
familyof coordinationmechanisms,
calledGeneralized
Partial
GlobalPlanning(GPGP).Theset of coordinationmechanisms
described
hereassists in scheduling
activitiesfor teamsof cooperative computational
agents. TheGPGP
approachhas several
uniquefeatures.First, it is not tied to a singledomain.
Each
mechanism
is definedas a responseto certain features in the
current task environment.Weshowthat different combinations of mechanisms
are appropriatefor different task environments.Secondly,the approachworksin conjunctionwith
an agent’sexistinglocal planner/scheduler.
Finall};the initial
set of five mechanisms
presentedhere generalizesandextends
the Partial GlobalPlanning(PGP)algorithm.In comparison
to PGRGPGP
considerstasks withdeadlines,it allowsagent
heterogeneity,
it exchanges
less globalinformation,
andit communicates
at multiplelevelsof abstraction.
Introduction
This paper presents a formal description of the implementation of a domainindependent coordination scheduling approach which we call Generalized Partial Global Planning
(GPGP).The GPGP
approach consists of an extendable set
modularcoordination mechanisms,any subset or all of which
can be used in responseto a particular task environment.Each
mechanism
is defined using our formal frameworkfor expressing coordinationproblems(TFr_,MS
(Decker&Lesser i 993b)).
GPGP
both generalizes and extends the Partial Global Planning (PGP)algorithm (Durfee &Lesser 1991). Our approach
has several unique features: GPGP
worksin conjunction with
an existing agent architecture and local scheduler1; each coordination mechanism
is definedas a responseto certain features
in the current task environment;the individual coordination
mechanisms
rest on a shared substrate that arbitrates between
"This work was supported by DARPA
contract N00014-92-J1698, Office of NavalResearchcontract N00014-92-J-1450,
and
NSFcontract IRI-9321324.Thecontent of the informationdoes
not necessarilyreflect the positionor the policyof the Government
andno official endorsement
shouldbe inferred.
1 Here,a "design-to-time"
real-timescheduler(Garvey&Lesser
1993).
the mechanisms
and the agent’s local scheduler in a decisiontheoretic manner.
The GPGPapproach views coordination as modulating local control, not replacing it. This processoccursvia a set of
domain-independentcoordination mechanismsthat post constraints to the local scheduleraboutthe importanceof certain
tasks and appropriate times for their initiation and completion. By concentrating on the creation of local scheduling
constraints, we avoid the sequentiality of schedulingin the
original PGPalgorithm that occurs whenthere are multiple
plans. By havingseparate modulesfor coordination and local
scheduling,wecan also take advantageof advancesin real-time
schedulingto producecooperativedistributed problemsolving
.systems that respondto real-time deadlines. Wecan also take
advantageof local schedulersthat havea great deal of domain
scheduling knowledgealready encodedwithin them. Finally,
our approachallows consideration of termination issues that
were glossed over in the PGPwork (where termination was
handledby an external oracle).
Besides the obvious connections to the earlier PGPwork,
GPGPbuilds on work by yon Martial (v. Martial 1992)
in detecting and reacting to relationships (such as yon
Martial’s "favor" relationship). GPGPalso uses a notion
of social commitmentssimilar to those discussed by (Cohen &Levesque 1990; Shoham1991; Castelfranchi 1993;
Jennings 1993). Durfee’s newer work (Durfee & Montgomery
1991)is basedon a hierarchical behaviorspace representation
that like GPGPallows agents to communicateat multiple
levels of detail. The mechanismspresented in this paper
deal with coordination while agents are scheduling (locating
in time) their activities rather than while they are planning
to meet goals. This allows themto be used in distributed
scheduling systems, agenda-basedsystems (like blackboard
.vstems), or systems whereagents instantiate previous plans
(like case-based planning systems). The focus on mechanismsfor coordinating schedulesis thus different from work
that focuses on multi-agent planning (Grosz &Kraus 1993;
Ephrati & Rosenschein 1994). Shohamand Tennenholtz’s
’social laws’ approach (Shoham&Tennenholtz1992) can
viewedas one whichtries to changethe (perceived) structure
of the tasks by, for example,restricting the agents’ possible
activities. Intelligent agents mightuse all of these approaches
at one time or another.
Decker
73
From: Proceedings of the First International Conference on Multiagent Systems. Copyright © 1995, AAAI (www.aaai.org). All rights reserved.
The next section will briefly re-introduce ottr framework
for representing coordination problems, and summarizethe
assumptionswe makeabout an agent’s internal architecture.
Wethen describe the GPGP
substrate and five coordination
mechanisms.2 Previous work has shownhow the GPGPapproach can duplicate and extend the behaviors of the P(;P
algorithm(Decker&Lesser1992); this paper will briefly sumnaarizeseveral experimentalresults that are reportedin (Decker
1995)and concludeswith a look at our future directions.
Representing The Task Environment
Coordination is the process of managinginterdependencies
betweenactivities (Malone&Crowston1991). If we view
agent as an entity that has somebeliefS; about the worldand
can perform actions, then the coordination problemarises
whenan)" or all of the followingsituations occur: the agent
has a choiceof actions it cantake, and that choiceaffects the
agent\ performance;the order in whichactions are carried
out affects performance;the time at whichactions are carried
out affects performance.The coordination problemof choosing and temporally ordering actions is mademore complex
because the agent mayonly have an incomplete view of the
entire task structure of whichits actions are a part, the task
structure maybe changing dynamically and the agent m.’ly
be uncertain about the outcomesof its actions, if there are
multiple agents in an environment,then whenthe potential
actions of one agent are related to those of anotheragent, we
call the relationship a coordinationrelationship. EachGPGP
coordination mechanismis a response to somecoordination
relationship.
The T/EMSframework(Task Analysis, EnvironmentModeling, and Simulation) (Decker & Lesser 1993b) represents
coordination problemsin a I’brmal, domain-independent
way.
Wehave used it to represent coordination problemsin distributed sensor networks,hospital patient scheduling,airport
resource management,
distributed information retrieval, piIot~ associate, local area networkdiagnosis, etc. (Decker
1995).In this paper wewill describe an agent’s current st*bjective beliel’~saboutthe structureof the problem
it is tryingto
solve by using the "I’/EMS framework(Decker&Lesser 1993b:
Decker1995). For this purpose, there are twouniquef~arures
of T2F.MS.
Thefirst is the explicit, quantitativerepresentation
of task interrelationshipsas functionsthat describethe et}bct of
activity choices and temporalorderi,lgs on perfbrmance.The
secondis the representationof task structuresat multiplelevels
of abstraction. Thehighestlevel of abstractionis called a task
group,and contains all tasks that haveexplicit computational
interrelationships.Atask is simplya set of lower-levelsubtasks
and/or executable methods. The componentsof a task have
an explicitly definedeffect on the quality of the encompassing
task. Thelowestlevel of abstraction is called an exect, table
method.Anexecutablemethodrepresents a schedulableentitb
such as a blackboardknowledgesource instance, :1 chunkof
codeand its input data, or a totally-orderedplan that has been
recalled and instantiated fbr a task. A methodcould also be
2Thesefive mechanisms
are orientedtowardsproducing
P( ;P-like
"cooperative
team’behavior.
Mccl|anisms
for .~cll’-inreresred
age,atsarc
alsopossible.
74
ICMAS-95
an instanceof a human
activity at someuseful level of detail,
tbr example,"take an X-rayof patient I’s left foot".
A coordination probleminstance (called an episode E) is
defined as a set of task groups, each with a deadline D(T),
such .’Is E = (~. "T~ ..... T,, ). A common
performancegoal
of the agent or agents is to maximizethe sumof the quality
achievedfbr each task groupbdbreits deadline.
Figure I showsan objective:l task groupand agent A’s subjective viewof that sametask group.Tile arrowsbetweentasks
and/or methodsindicate task interrelationships wherethe execution of so,he methodwill havea positive or negativeef}~ct
on the quality or duration of another method.The presence
of these interrelationships makethis an NP-h.ardscheduling
problem:further complicatingf~tctors for the local scheduler
include the I’hct that multiple agents are executingrelated
methods, that somemethodsare redundanr (executable at
morethan one agent), and that the subjective task structure
maydiffer fromthe real objective structure.
The Agent Architecture
Wemakefewassumptionsabout the architecture of the agents.
The agents have a database that holds their current belid~s
about the structure of tile tasks in the current episode; we
represent this infbrmation using TA’.MS.The agents can do
dtree types of actions: they can executemethodsfromthe task
structure, send direct messagesto one another, and do "’information gathering". Infbrmation gathering actions modelhow
new task structures or communications
get into the agent’s
belief database. This could be a combinationof external actions (checkingthe agent’s incomingmessagebox) and internal
planning. Methodexectition actions cause quality to accrue
in a task group (as indicated by the task structure). Communication actions are used to send the results of merhod
executions(whichin turn maytrigger the efI’~cts of various
task interrelationships) or meta-levelinfbrmation.
Formallywewrite /’/~t(.r) to nle.’magent .-t subjectively
believes .~’ .’11 time t (Shoham
1991). Wewill shorten this
to /3(.r) whenthe particular agent or time is obvious.
agent’ssubiectivebelief~saboutthe current episodeincludethe
agent’s beliefs abouttask groups,subtasks, execut:tble methods, and interrelationships (e.g., D(’T~E E). B(T,,, ."~11,
"T~)./3(enables(S/’;,,
:~,1~.))).
The GPGPfamily of coordination mechanismsalso makes
a stronger assumptionaboutthe agent architecture. It assumes
the presenceof a local schedulingmechanism
(to be described
in the next section) that can decide what methodexecution
actions should take place and when.The local scheduler attempts to maximizea (possibly changing) utility ftmction.
The current set of GPGPcoordination mechanismsare for
cooperative reamsof agents--they assumethat agents do not
intentionally lie and that agents believe whatthey are told.
I Iowever, because agents can believe and communicate
only
subjective information,the)’ mayunwittinglytransmit informationthat is inconsistent with an objective view (this can
cause, amongother things, the phenomena
of distraction). Finally, tile GPGP
fhmily approachrequires domain-dependent
’*l’hew,lrd "td~jcct*vc’
rctbrsto thefactthat*’llis i~ thetrue,real
’qI’1i(’rll rt’.
From: Proceedings of the First International Conference on Multiagent Systems. Copyright © 1995, AAAI (www.aaai.org). All rights reserved.
me~(=ecur.ble
mk~
@
task with quality
accrual function rain
subtask rdationship
enables relationship
c~ai~atcs
relationship
Figure h AgentAand B’Ssubjective views(bottom)of a typical objective task group(top)
codeto detect or predict the presenceof coordination relationshipsin the local task structure. In this paperwewill refer
to that domain-dependentcode as the information gathering
action called detect-coordination-relationship~
wewill describe
this action more in the section on Mechanism
1: Non-Local
Views.
The Local Scheduler
EachGPGP
agent contains a local scheduler that takes three
types of input information and produces a set of schedules
and alternatives. Thefirst input is the current, subjectively
believedtask structure. Usinginformationaboutthe potential
duration, potential quality, and interrdationships, the local
scheduler choosesand orders executablemethodsin an attempt
to maximizea pre-defined utility function. In this paper
the utility function is the sumof the task group qualities
~’~T~EQ(T, D(T)), where Q(T, t) denotes the quality ofT
at time t as defined in (Decker&Lesser 1993b).Quality does
not accrueafter a task group’sdeadline.
The secondinput is a set of commitmentsC. Thesecommitments are produced by the GPGPcoordination mechanisms,
and act as extra constraints on the schedulesthat are produced
by the local scheduler. For example,if methodI is executable
by agent A and method2 is executable by agent B, and the
methodsare redundant, then one of agent A’s coordination
mechanismsmay commit agent A to do method 1. Commitmentsare social--directed to particular agents in the sense of
the work of Castdfranchi and Shoham(Castdfranchi 1993;
Shoham 1991)). A local commitment C by agent A becomes a non-local commitmentwhen received by another
agent B. This paper will use two types of commitments:
C(Do(T,q)) is a commitment
to ’do’ (achieve quality for)
andis satisfied at the timet whenQ(T,t) >_q; the secondtype
C(DL(T,q, tat)) is a ’deadline’ commitment
to do T by time
tdt andis satisfied at the timet when[Q(T,t) > q] A[t <_ tat].
Whena commitment
is sent to another agent, it also implies
that the task result will be communicated
to the other agent
(by the deadline, if it is a deadlinecommitmen0.
The third input to the local scheduler is the set of nonlocal commitments NLCmade by other agents. This information can be used by the local scheduler to coordinate actions betweenagents. For examplethe local scheduler could have the property that, if methodM, is executable by agent A and is the only method that enables
method Ms at agent B (and agent B knows this), and
BA(C(DL(M,,
q, tl)))E BB(NLC),
thenforeveryscbedule S produced by agent B, (M2,t) 6 S =6 t ~1(in
other words,agent B only schedulesthe enabledmethodafter
the deadline that agent A has committedto.
A schedule S produced by a local scheduler will
consist of a set of methods and start times: S =
{(M1, tl), (Ms, t2),..., (M,, tn)}. The schedule may
dude idle time, and the local schedulermayproducemorethan
one scheduleuponeach invocation in the situation wherenot
all commitments
can be met. Thedifferent schedulesrepresent
different waysof partially satisfi/ing the set of commitments.
The function Violated(S) returns the set of commitments
that are bdievedto be violated by the schedule. For violated
deadline commitments C(DL(T, q, tdt)) Violated(S)
the function Alt(C, S) returns an alternative commitment
C(DL(T,q,t*dl)) where t~t = mint such that Q(T,t) >_
if such a t exists, or NIL otherwise. For a violated Do
commitmentan alternative may contain a lower minimum
quality, or no alternative maybe possible. The fimction
Uest(E, S, NLC)returns the estimated utility at the end
the episode if the agent follows scheduleS and all non-local
commitmentsin NLCare kept.
Thus we may define the local scheduler as a function LS(E,C, NLC) returning a set of schedules S
{S,, Ss,... ,St a}. Moredetailed information about this
kind of interface betweenthe local scheduler and the coordination component maybe found in (Garvey, Decker,
Lesser1994). Thisis an extremdygeneral definition of the local scheduler, and is the minimalone necessaryfor the GPGP
coordination module.Stronger definitions than this will be
neededfor morepredictable performance,as we will discuss
Decker
75
From: Proceedings of the First International Conference on Multiagent Systems. Copyright © 1995, AAAI (www.aaai.org). All rights reserved.
later. Ideally, the optimal local scheduler wouldfind both
the schedule with maximum
utility Su and the schedule with
maximum
utility that violates no commitments
6f,. In practice, however,a heuristic local scheduler will producea set
of schedules wherethe schedule of highest utility Su is not
necessarily optimal: U(E, Sv, NLC)<_ U(E, S’tr, NLC).
Five GPGP Coordination
Mechanisms
Therole of the coordination mechanisms
is to provide informationto the local schedulerthat allows the local scheduler
to construct better schedules. This informationcan be in the
formof modificationsto portionsof the subjective task structure of the episodeor in the formof local and non-localcommitmentsto tasks in the task structure. The five mechanisms
wewill describe in this paper forma basic set that provides
similar functionality to the original Partial GlobalPlanning
algorithm as shownin (Decker & Lesser 1992). Mechanism
exchangesuseful private viewsof task structures; Mechanism
2
communicatesresults; Mechanism
3 handles redundant methods: Mechanisms
4 and 5 handle hard and soft coordination
relationships. Moremechanisms
can be added, such a~s one to
updateutilities acrossagents as discussedin the next section,
or to balance the load better between agents. The mechanisms are independentin the sense that they can be used in
any combination.If inconsistent constraints are introduced,
the local schedulerwill return at least one violated constraint
in all its schedules.Sincethe local schedulertypicallysatisfices
instead of optimizes,it maydo this evenif constraints are not
inconsistent (i.e. it does not search exhaustively). Thenext
section describes howa scheduleis chosenby the coordination
modulesubstrate.
The GPGPCoordination Module Substrate
All the specific coordination mechanismsrest on a common
substrate that handles informationgathering actions, invoking
the local scheduler, choosinga scheduleto execute (including dealing with violated or inconsistent commitments),and
deciding whento terminate processing on a task group. Information gathering actions include noticing newtask group
arrivals and receiving communications
from other agents. Informationgathering is doneat the start of problemsolving,
when communicationsare expected from other agents, and
whenthe agent is otherwise idle. Communications
are expected in responseto certain events (such as after the arrival
of a newtask group) or as indicated in the set of non-local
commitmentsNLO.This is the minimal general information
gathering policy. Terminationof processing on a task group
occurs for an agent whenthe agent is idle, has no expected
communications, and no outstanding commitmentsfor the
t.ask group.
Choosinga schedule is morecomplicated. The agent’s local scheduler mayreturn multiple schedulesbecauseit cannot
find a single schedulethat both maximizesutility and meets
all commitments.Fromthe set of schedules S returned by the
local scheduler, twoparticular schedulesare identified: the
schedulewith the highest utility St; and the best committed
scheduleSo:. If they are the same,then that scheduleis cho76
ICMAS-95
sen. Otherwise,weexaminethe sumof the changesin utility
for each commitment.Each commitment,when created, is
assignedthe estimatedutility U~stfor the task groupof which
it is a part. This utility maybe updatedovertime (whenother
agents depend on the commitment,for example). Wethen
choosethe schedulewiththe largest positive changein utility.
This allows us to abandoncommitments
if doingso will result
in higher overall utility. Thecoordinationsubsttate does not
use the local scheduler’sutility estimateU~,stdirectly on the
entire schedulebecauseit is basedonly on a local view. The
coordinationsubstrate mayreceive non-localinformationthat
places a higher utility on a commitment
than it has locally.
If both scheduleshavethe sameutilits; the one that is more
negotiable is chosen. Every commitment
has a negotiability
index (high, medium,or low) that indicates (heuristically)
the difficulty in reschedulingif the commitment
is broken.
This index is set by the individual coordinationmechanisms.
For example,hard coordinationrelationships like enablesthat
cannot be ignored will trigger commitments
with low negotiability. If the schedulesare still equivalent,the shorter one
is chosen, and if the), are the samelength, one is chosenat
random.
After a scheduleS is chosen, if Viol&ted(S)is not empty,
then each commitmentC E Violated(S) is replaced with its
alternative C ~ C \ C LI AIr(C, S). If the commitment
madeto other agents, the other agents are also informedof
the change in the commitment.Whilethis could potentially
cause cascading changesin the schedules of multiple agents,
it generallydoesnot for three reasons:first, as wementioned
in the previous paragraph legs important commitmentsare
brokenfirst; secondly;the resiliancy of the local schedulers
to solve problemsin multiple waystends to dampout these
fluctuations; and third, agents are time cognizantresourceboundedreasoners that interleave execution and scheduling
(i.e., the agents cannotspendall day arguing over scheduling
details and still meettheir deadlines). Wehaveobservedthis
useful phenomenon
before (Decker1995) and plan to analyze
it in future work.
Mechanism 1: Updating Non-Local Viewpoints
Remember
that each agent has only a partial, subjective view
of the current episode. The GPGPmechanism described
here can communicate
no private information(’none’ policy,
no non-localview), or all of it (’all’ policy, globalview),
take an intermediate approach(’some’policy, partial view).
The process of detecting coordination relationships between
private and sharedparts of a task structure is in generalvery
domainspecific, so we modelthis process by a newinformation
gatheringaction, detect-coordination-rdationships,
that takes
somefixed amountof the agent’s time. This action is scheduled
whenevera newtask grouparrives.
The set P of privately believed tasks or methodsat an
agent A (tasks believed at arrival time by A only) is then
{~ I task(:r) A Va E A \ A, -~BA(/3~f~)(a:))}, where
the set of all agents and Ar(x) is the arrival time ofz. Given
this definition, the action derect-caardination-relationships
returns the set of private coordination relationships PCR=
{r[ Tt E P A 7"2 ~’ P A [r(Tt,T2) V r(T2, T1)]} between
From:
Proceedings
of the First
International
Conference
on reMultiagent Systems. Copyright © 1995, AAAI (www.aaai.org). All rights reserved.
private
and
mutuallybelieved
tasks.
The action
does not
set of potential redundancies RCR= {r ¯ cg [ [r =
turn whatthe task T2is, just that a relationshipexists between
subtask(T, M, rain)] A [VM¯ M, method(M)]}. Then for
T1 and some otherwise unknowntask T2. For example, in
all methodsin the current scheduleS at time t, if the method
is potentially redundantthen committo it and send the comthe DVMT,
we have used the physical organization of agents
mitment to Others(M) (non-local agents whoalso have
to detect that AgentA’s task T1 in an overlappingsensor area
method in M):
is in fact related to someunknown
task T2 at agent B (i.e.
BA(BB(Ts))) (Decker & Lesser 1992). The non-local view
[(M, tM) e S]
coordination mechanismthen communicatesthese coordi[subtask(T, M, min) ¯ RCR]A [M ¯ M]
nation relationships, the private tasks, and their context: if
[C(Do(M,Q..t(M,D(M),S)))
¯ C] A
r(Tt, Ts) PCR and T16 Pth enr and T1will be com[comm(M,
Others(M),
t)
¯
municatedby agent A to the set of agents {a ] BA(Ba (T2))
For example,Figure 2 showsthe local subjective beliefs of
See for examplethe top of figure :5--both agents committo
agents A and B after the communicationfrom one another
Dotheir methodsfor T,.
due to this mechanism.We’ll denote the completeset of coAfter the commitment
is made,the agent must refrain from
ordination relationships as GR;this indudesall the elements
executing the methodin question if possible until any nonof PCRand all the relationships betweennon-private tasks.
local commitments
that were madesimultaneously can arrive
(the communicationdelay time/~). This mechanismthen
Mechanism 2: Communicating Results
watches for multiple commitmentsin the redundant set and
if they appear, a uniqueagent is chosenrandomly(but identiThe result communicationcoordination mechanismhas three
cally by all agents) from those with the best commitments
to
possible policies: communicate
only the results necessary m
keep its commitment.
All the other agents can retract their
satisfy commitmentsto other agents (the minimalpolicy);
commitments.For examplethe bottomof figure :5 showsthe
communicate
this informationplus the final results associated
situation after AgentB has retracted its commitment
to Do
with a task group (’TG’ policy), and communicate
all results
B,. If all agents follow the same algorithm, and communi(’all’ policy4). Extra result communications
are broadcastto all
cation channels are assumedto be reliable, then no second
agents, the minimal commitment-satisfyingcommunications
message(retraction) actually needsto be sent (becausethey
are sent only to those agents to whomthe commitmentwas
choose the same agent to do the redundant method). In the
made(i.e., communicate
the result of T to the set of agents
implementationdescribed later, identical randomchoices are
{A 6 A [ B(BA(C,(T))).
madeby giving each methoda unique randomidentifier, and
then all agents choosethe methodwith the ’smallest’ identifier
Mechan;sm 3: Handling Simple Redundancy
for execution.
Potential redundancy
in the efforts of multiple agents can ocInitially, all Do commitments
initiated by the redundant
cur in several places in a task structure. Anytask that uses a
coordination
mechanism
are
marked
highly negotiable. When
’max’quality accumulationfunction (one possible semantics
a redundantcommitment
is discovered,the negotiability of the
for an ’OR’node)indicates that, in the absenceof other reremaining commitmentis lowered to mediumto indicate the
lationships, only one subtask needs mbe done. Whensuch
commitmentis somewhatmore important.
subtasks are complexand involve manyagents, the coordination of these agents to avoid redundantprocessingcan also be
Mechanism 4: Handling Hard Coordination
complex;we will not address the general redundancyavoidRelationships
ance problemin this paper (see instead (Lesser 1991)). In
Hardcoordination relationships include relationships like
original PGPalgorithm and domain(distributed sensor inenables(M,, Ms) that indicate that M1must be executed
terpretation), the primary form of potential redundancywas
before Msin order to obtain quality for Ms. Like redunsimple methodredundancy--thesame result could be derived
dant methods, hard coordination rdationships can be culled
from the data from any of a numberof sensors. The coorfrom the set CR. The hard coordination mechanismfurther
dination mechanismdescribed here is meantto address this
distinguishes the direction of the relationship--the current
simpler form of potential redundancy.
implementationonly creates commitmentson the predecesThe idea behind the simple redundancycoordination mechsors of the enables relationship. We’ll let HPCRC CR
anism is that whenmore than one agent wants to execute a
indicate the set of potential hard predecessorcoordinationreredundant method, one agent is randomly chosen to exelationships. The hard coordination mechanism
then looks for
cute it and send the results to the other interested agents.
situations wherethe current schedule S at time t will proThis is a generalizationof the ’static’ organizationalgorithm
duce quality for a predecessor in HPCR,and commitsto its
discussed by Deckerand Lesser (Decker & Lesser 199:sa)-executionby a certain deadlineboth locally andsocially:
it does not try to load balance, and uses one communi[Q.,t(T,D(T),S) > 0] A
cation action (because in the general case the agents do
[enables(T, M) ¯ HPCR]=~
not knowbeforehand, without co- mmunication,tha-t certain
methods are redundantS). The mechanism considers the
[C(DL(T,
Q..t(T,
D(T),
S),t-.a.,y))
A
[comm(C,Others(M),t) ¯
4Sucha policyis all that is neededin many
simpleenvironments.
SThedetection of redundantmethodsis domain-dependent,
as
redundancy(i.e. doingthe exact samemethodat morethan one
discussedearlier. Sinceweare talking here aboutsimple,direct
agent)this detectionis verystraight-forward.
Decker
77
From: Proceedings of the First International Conference on Multiagent Systems. Copyright © 1995, AAAI (www.aaai.org). All rights reserved.
task
withqualitytask)
~ method
(executable
accrual
function
rain
subtaskrelationship
- - - -~enablesrelationship
Al~tA’sviewafter~mm~i~n
fromB
Figure 2: AgentsA and B’s local views after
Figure1 showsthe gents’ initial states.
~,ntB’svi~a~rc~’nr~ni~i~
r~mA
receiving
non-local viewpointcommunications
via mechanism
1 (shaded objects).
Thenext question is, by whattime (tearly above) do wecommit mprovidingthe answer?Onesolution, usablewithany local schedulerthat fits our generaldescriptionof a LocalScheduler, is to use the rain t such that Q~t(T,D(T),S) > 0.
our implementation,the local scheduler provides a query facility that allows us to propose a commitment
to satisfy as
’early’ as possible (thus allowingthe agent on the other end
of the relationship moreslack). Wetake advantageof this
ability in the hard coordination mechanismby adding the
new commitmentU(DL(T,Qe,t(T, D(T), S), "early"))
the local commitment
set C, and invokingthe local scheduler
L,.q(E, C, NLC)to producea newset of schedules S. If the
preferred, highest utility schedule5tl E S has no violations
(highly likely since the local schedulercan simplyreturn the
samescheduleif no better one can be found), we replace the
current schedulewith it and use the newschedule, with a potentially earlier finish timefor T, to providea valuefor tea~ly.
The newcompleted commitment
is entered locally (with low
negotiability)andsent to the subsetof interested other agents.
If redundant commitments
are madeto the same task, the
earliest commitment
madeby any agent is kept, then the agent
committingto the highest quality, and any remainingties are
broken by the same methodas before.
Currently, the hard coordination mechanism
is a pro-active
mechanism,providing information that might be used by
other agents to them, while not putting the individual agent
to any extra effort. Other future coordination mechanisms
might be added to the family that are reactive and request
fromother agents that certain tasks be doneby certain times;
this is quite different behaviorthat wouldneedto be analyzed
separately.
Mechanism 5: Handling Soft Coordination
Relationships
Soft coordination relationships are handled analogously to
hard coordination relationships except that they start out
with high negotiability. In the current implementation
78
ICMAS-9$
the predecessorof a facilitates relationship is the only one
that triggers commitmentsacross agents, although hinders
relationships are also present. The positive relationship
facilitates(M1, M2,~d, ~q) indicates that executing M1before M2decreases the duration of Msby a ’power’ factor
related to ~a and increases the maximum
quality possible by
a power factor related to ¢q (Decker &Lesser 1993b).
moresituation-specific version of this coordination mechanism might ignore relationships with very low power. Figure 3 shows Agent B makinga D commitmentto do method
/34, whichin turn allows Agent A mtake advantage of the
facilitates(T4, T1, 0.G, 0.5) rdationship, causing method
to take only half the time and produce1.5 times the quality.
Overhead
Theprimarysources of overheadassociated with the coordination mechanismsinclude action executions (communication
and informationgathering), calls to the local scheduler, and
any algorithmic overheadassociated with the mechanismitself. Table 1 summarizesthe total amountof overheadfrom
each source for each coordination mechanism
setting and the
coordinationsubstrate. L represents the length of processing
(time before termination), and d is a general density measure
of coordination relationships. Interactions betweenthe presence of coordinationmechanisms
and these quantities include:
the numberof methodsor tasks in E, whichdependson the
non-local view mechanism;the numberof coordination relationships ICRI
or the subsets RCR(redundant coordination
relationships), HPCR
(hard predecessor coordination relationships), SPCR(soft predecessor coordination relationships), which dependson the numberof tasks and methods
as well; and the numberof commitments
ICI, whichdepends
on each of the three mechanismsthat makescommitments.
Conclusions, Status, and Future Work
This paper discusses the design of an extendable family of
coordination mechanisms,called Generalized Partial Global
From: Proceedings of the First International Conference on Multiagent Systems. Copyright © 1995, AAAI (www.aaai.org). All rights reserved.
;.mEn..:
"~~
TI
;
T2
’~
¯
ti
’m=,
.........
Commitmmts
made
fromAto B:
DO0kl,100)
[Herb ~1
matt from B ~ A..
ICommitmam
DL(T4,50,5)
[Merit#S]J
Do(B1,100)
l’Mech#3]
I
tm2
I
t--$
t--13
i
’,. millt
, TI ’ae~-...--.,..~
: T2 ,
max ’
; inin,
;"~’;""
"~....
B-~
W[--’i too.
c.,,,,/~-,=
~.,~,,,A~,a|
$c&duL-s..
~.2
t.5
A~,atA ’s titw ~ft~r raia~i~fB’s commitmems
’.._~
B3"
5t
Do(A1,150)
[~.h s~] J
_OL_~4:5_O_:5)__gM~
~1_
.I i
I
-".......
.............
¯ ¯
t
I
t=IO
A~: B’s ~kw~fr~r ra’dui~ A ’: commi~wms
Figure 3: A continuation of Figures 1 and 2. At top: gents A and B proposecertain commitments
to one another via mechanisms
3
and 5. At bottom: after receiving the initial commitments,mechanism3 removesagent B’S redundant commitment.
Planning (GPGP),that form a basic set of schedule coordination mechanismsfor teams of cooperative computational
agents. An.importantfeature of this approachincludes an extendable set of modularcoordination mechanisms,any subset
or all of whichcan be used in responseto a particular task
environment.This subset maybe parameterized, and the parameterization does not have mbe chosenstatically, but can
instead be chosenon a task-group-by-task-group
basis or even
in responseto a particular problem-solving
situation. For example, Mechanism5 (Handle Soft Predecessor CRs) might
be =on=for certain dashesof tasks and ’off’ for other classes
(that usually have ~sv or very weaksoft CRs). The general
specification of the GPGP
mechanisms
involves the detection
and responseto certain abstract coordinationrelationships in
the incomingtask structure that werenot tied ma particular
domain~we
have used TraMSto describe tasks as diverse as
distributed sensor networks,hospital scheduling,and Internet
informationgathering. A careful separation of the coordination mechanisms
from an agent’s local scheduler allows each
mbetter do the job for which it was designed. Webdieve
this separation is not only useful for applyingour coordination mechanisms
to problemswith existing, customizedlocal
schedulers, but also to problemsinvolving humans(wherethe
coordination mechanism
can act as an interface mthe person,
suggesting possible commitments
for the person’s consideration and reporting non-local commitmentsmadeby others)
(Decker &Lesser 1995).
The GPGP
coordination approachas described in this paper
has beenfully implemented
in the TFv_.MS
simulation testbed.
Significant experimental validation of the GPGPapproach
is documentedin (Decker 1995). These experiments have
demonstratedthe effective performanceof the current mechanisms and the range of behaviors possible. Wedemonstrate
that in complextask environmentsagents that use the appropriate mechanisms
performbetter than agents that do not
for several performancemeasures. Weshowhowto test that
a particular mechanismis useful. Weshowthat different
combinationsof mechanisms
are, in fact, neededin different
environments.Wedescribe a wayto structure the search for
a particular combinationof mechanisms
in a particular enviDecker
79
From: Proceedings of the First International Conference on Multiagent Systems. Copyright © 1995, AAAI (www.aaai.org). All rights reserved.
Mechanism
setting Communications Information
Gathering Scheduler
substrate o
L
E+idle
nlv none
o
0
t)
Some’
Edetect-CRs
O(dP)
0
all O(P)
Edetect-C.’lts
0
commrain O(C)
0
0
TG O(C + E)
0
0
all o(M ¯ E)
0
0
redundanton O(RCR)
0
0
hard an O(HPCR)
0
O(HPCR)
SO}’[ O?/
O(SPCR)
0
O(SPCR)
( )ther( )t,erhead
o(Lc)
o
O[T E E)
O(T ¯ E)
O(C)
O(C + E)
O(.Xt¯ E)
O(RCR¯ .q +CR)
+
O(HPCR * + CR)
O(SPCR¯ .%’+ CIt)
"Fable 1 : Overheadassociated with individual mechanisms
at each parametersetting
ronment,starting fromcertain architypical clusters of mechanisms. Our experimentshave also shownthe value of structuring coordination in terms of a fhmily of algorithms and
the ease of adding newmechanisms
such as a cooperative load
balancing mechanism.The cooperative load-balancing coordination mechanismworks by providing better infbrmation
to the agents with whichto resolve redundantcommitments.
Eventuallyweintend to developa library of reusablecoordination mechanisms.For example, mechanismsthat work from
the successorsof hardand soft relationshipsinstead of the predecessors, negotiation mechanisms,mechanismsfbr behavior
such as contracting, or mechanisms
that can be used by self
motivated agents in non-cooperative environments. Manyof
these mechanisms
can be built on the existing workof other
DAIresearchers. Future workwill also examineexpandingthe
parameterization of the mechanisms
and using machinelearning techniquesto choosethe appropriateparametervalues (i.e.,
learning the best mechanism
set for an environment).Finally,
we are also beginning work on using the GPGPapproach
in applications ranging from providing humancoordination
assistance to distributed infbrmationgathering.
References
Castelfranchi, C. 1993. Commitments:from
individual intentions to groupsand organizations. In Prietula, M., ed.,
AI and theories of groups &organizations: Conceptualand
Empirical Research. AAA!Workshop.WorkingNotes.
Cohen,P. R., and Levesque,H.J. 1990. Intention is choice
with commitment.Artificial Intelligence42(3):213-261.
Decker, K. S., and Lesser, V. R. 1992. Generalizing the
partial global planningalgorithm.Intnl. Jrnl. of Intelligent
and CooperativeInformationSystems I (2):319-346.
Decker, K. S., and Lesser, V. R. 1993a. An approach to
analyzing the need for meta-level communication.In Proceedingsof the Thirteenth International Joint Conferenceon
Artificial Intelligence, 360-366.
Decker, K. S., and Lesser, V. R. 1993b. Quantitative modeling of complexcomputationaltask environments.In Proc.
of the EleventhNational Conferenceon AL 217-224.
Decker, K. S., and Lesser, V. R. 1995. Coordinationassistance for mixed humanand computational agent systems.
UMassTechnical Report 95-31.
80
ICMAS-95
Decker, K. S. 1995. EnvironmentCentered Analysis andDesign of C’oordinationMechanisms.Ph.D. Dissertation, University of Massachusetts.
Durfee, E., and Lesser, V. 1991. Partial global planning: A coordination frameworkfbr distributed hypothesis
fbrmation. IEEETrans. on Systems, Man,and Cybernetics
21(5):1167-1183.
Durfee, E. H., and Montgomer);T. A. 1991. Coordination
as distributed search in a hierarchical behaviorspace. IEEE
Trans. on Systems,Man.and Cybernetics21 (6):I
363-1378.
t’phrati, E., and Rosenschein,J. 1994. Divideand conquerin
multi-agentplanning. In Proceedingsof the Twelfth National
Con/brence
on Artificial Intelligence, 375-380.
GarveyA., and Lesser, V. 1993. Design-to-time real-time
scheduling. IEEETransactions on Systems, Man,and Cybernetics23(6):1491-1502. See also updated UMassTR95-03.
(.;arve,~; A.; Decker,K.; and [,e~ser, V.1994.A negotiationbasedinterface betweena real-time schedulerand a decisionmaker. UMassTechnical Report 94-08.
Grosz, B., and Kraus, S. 1993. Collaborativeplans for group
activities. In l¥oceedingsof the ThirteenthInternationalJoint
Confirence
onArtificial Intelligence.
Jennings, N. R. 1993. Commitmentsand conventions:
The foundationof coordination in multi-agent systems. The
Knou.ledgeEngineeringReview8(3):223-250.
Lesser, VR. 199I. Aretrospective viewof FA/Cdistributed
problemsolving. IEEETransactions on Systems. Man.and
Cybernetics21 (6):1347-1363.
Malone,"l: W., and Crowston,K. 1991. Towardan interdisciplinary theory of coordination. Center for Coordination
Science Technical Report 120. MITSloan School.
Shoham,Y., and Tennenholtz, M. 1992. On the synthesis
of useful social lawsfor artificial agent societies (preliminary
report). In Proceedingsof the Tenth NationalGmferenceon
Artificial Intelligence,276-281.
Shoham,Y. 1991. AGENT0:
A simple agent language and
its interpreter. In l¥oceedingsof the NinthNationalConference
onArtificial Intelligen,’e, 704-709.
~: Martial, E 1992. CoordinatingPlansof Autonomous
A~ents.
Berlin: Springer-Verlag.I..ecture Notesin AI #610.