COORDINATING AGENTS
An Analysis of Coordination in Supply-chain Management Tasks
Chetan Yadati, Cees Witteveen and Yingqian Zhang
Dept of Software Technology, Delft University, Mekelweg 4, 2628 CD Delft, The Netherlands
Keywords:
Multi-agent planning, Coordination mechanisms, Approximation algorithms.
Abstract:
A multi-agent planning problem consists of a set of activities that need to be planned by several agents.
Here, plan coordination methods play an important role, since the independently generated plans by different
agents can lead to an infeasible joint solution. We study one particular plan coordination approach, called
coordination-by-design, which allows each agent to make its own plan completely independent of the others,
while guaranteeing the feasibility of the combined plan of all the agents as a joint solution to the multi-agent
planning problem. In this paper, we are interested in a class of multi-agent planning problems that arise in
supply-chain management applications. Although the coordination problem in general is Σ
p
2
-complete, it turns
out for this special class, the complexity of coordination checking is polynomial and deciding a minimum co-
ordination set is NP-complete. We develop a polynomial-time approximation algorithm to compute a sufficient
coordination set.
1 INTRODUCTION
Multi-agent planning requires a collection of agents
to solve a joint problem together. Typically, each of
the agents is capable of solving only a (disjoint) part
of the problem and would like to choose its prob-
lem solving method, solution or plan independently
of the others. However, due to possible dependencies
between the solutions provided, it is not guaranteed
that these individual, partial solutions always can be
merged into a feasible overall solution. Therefore, we
need to provide a coordination mechanism. Let us
give a simple transportation example to illustrate the
need for such a coordination mechanism.
Example 1.1. We have to transport two packages p
1
and p
2
. Package p
1
at location X has to be deliv-
ered first to location Y (task t
1
), and then to location
Z (task t
3
); package p
2
at Z has to be delivered first
to Y (task t
4
) and then to X (task t
2
). There are also
two truck agents A
1
and A
2
. Agent A
1
can access lo-
cations X and Y , while agent A
2
can access only Y
and Z. To transport the packages, both agents have to
construct a move plan. If they would plan completely
independently from each other, agent A
1
could come
up with a plan to move from Y to X (transporting p
2
)
and then from X to Y (transporting p
1
). Likewise,
A
2
could decide first to move from Y to Z (transport-
ing p
1
) and then to move from Z to Y (transporting
p
2
). Combining those two plans, however, gives an
infeasible plan: both agents will have to wait for a
package to arrive at Y and therefore can not complete
their tasks. In this example, a coordination mecha-
nism could require A
1
to plan transporting p
1
before
p
2
, thereby ensuring the feasibility of a joint plan. 
Coordination in multi-agent planning can be
viewed as an attempt to achieve a conflict-free joint
plan given a set of self-interested multi-agent plan-
ners. In the multi-agent system community, quite
some effort has been done to attack this problem (Dur-
fee, 1999). The plan merging approach (Foulser et al.,
1992; von Martial, 1992; Tonino et al., 2002), for
example, focuses on the techniques that resolve con-
flicts after independently generated plans have been
developed by different agents. Here, agents are re-
quired to exchange, negotiate, and revise their (par-
tial) individual plans to arrive at a joint solution.
Another approach treats coordination and planning
as intertwined processes (Durfee and Lesser, 1991;
Ephrati and Rosenschein, 1993; Lesser et al., 2004),
where agents continuously exchange information dur-
ing their planning in order to achieve a conflict-
free solution. In these two coordination approaches,
218
Yadati C., Witteveen C. and Zhang Y. (2010).
COORDINATING AGENTS - An Analysis of Coordination in Supply-chain Management Tasks.
In Proceedings of the 2nd International Conference on Agents and Artificial Intelligence - Agents, pages 218-223
DOI: 10.5220/0002734002180223
Copyright
c
 SciTePress

agents have to be cooperative: they should be willing
to exchange their private information with others, and
to revise their plans if necessary.
We would like to address the problem from the
coordination-by-design perspective, that is, how to
provide just sufficient coordination constraints on
agents before the agents start to solve their own sub-
problem, such that (i) a joint solution is always co-
ordinated, yet (ii) each agent can construct its plan
independently from others. One advantage of such a
pre-planning coordination approach is that it can be
applied without relying on the assumption of cooper-
ativeness of the agents. The general results obtained
in this approach can be summarized as follows (Steen-
huisen et al., 2008): Checking whether or not agents
can plan independently without coordinating them is
a co-NP-complete problem. Secondly, finding a min-
imum number of constraints such that coordination is
achieved is Σ
p
2
-complete. Later, the authors presented
a polynomial algorithm, called the Depth-Partitioning
Algorithm, which can be used to obtain a sufficient
(but not necessarily minimum) set of coordination
constraints. However, it only has been shown that
this algorithm provides rather good results for logis-
tic planning problems (as used in the AIPS-planning
competition). Furthermore (ter Mors, 2004) identi-
fied two special cases where the coordination prob-
lem becomes computationally easier: the case where
an agent has at most one single task, and the cases
where all tasks with incoming or outgoing inter-agent
arcs are totally ordered amongst themselves. How-
ever, these two cases are very restricted and hardly
represent any real-world problems.
Built upon the previous work on the coordination-
by-design approach, our main contributions in this pa-
per are as follows:
Firstly, we identify a special class of interesting
multi-agent planning problems that is well-motivated
by supply chain management applications and we
demonstrate that these problems form a class of co-
ordination instances with a particular structure, called
intra-free instances (Section 3).
Secondly, we show (in Section 4) that for intra-free
coordination instances can be easily decided whether
they are coordinated or not, using a so-called agent
dependency graph and it can be showed that the
coordination problem becomes NP-complete, which
means the complexity can be lowered one step in the
polynomial hierarchy.
Thirdly, we propose a new polynomial approximation
algorithm for obtaining sufficient, but not necessar-
ily minimum, coordination sets for the intra-free in-
stances (Section 4.1).
Before presenting our main contributions, in the
next section we introduce a formal model of the multi-
agent coordination problem.
2 PRELIMINARIES
To formalize the multi-agent coordination problem,
we assume that there is complex task T that has to
be solved by a set A = {A
1
, . . . , A
n
} of agents. Such a
complex task is a partial order T =< T, ≺ > consist-
ing of a finite set T = {t
1
, . . . , t
m
} of primitive tasks
t
i
and a precedence relation ≺ on T , where t
i
≺ t
j
in-
dicates that t
i
must be completed before t
j
can start
1
.
Each task t ∈ T is assumed to be performed by a sin-
gle agent and we also assume that each agent A
i
has
already been assigned to a disjoint subset T
i
of T .
Hence, the set T can be represented by a partition-
ing {T
i
}
n
i=1
of T . Note that each block T
i
is partially
ordered by the relation ≺
i
obtained by restricting ≺
to T
i
.
We will often represent a coordination instance
T = h{T
i
}
n
i=1
, ≺i by an acyclic task graph G
T
=
hV
T
, E
≺
i, having T as it set of nodes and (t,t
0
) ∈ E
≺
iff t ≺ t
0
. For every T
i
, the associated subgraph G
T
i
=
hV
T
i
, E
≺
i
i of G
T
is defined analogously.
Example 2.1. Consider Example 1.1 discussed in the
previous section. The set of tasks T = {t
1
,t
2
,t
3
,t
4
} is
(partially) ordered by t
1
≺ t
3
;
2
similarly, t
4
≺ t
2
. As
the agents A
1
and A
2
can only access a part of the
infrastructure, the task allocation is as follows: T
1
=
{t
1
,t
2
} is assigned to agent A
1
, T
2
= {t
3
,t
4
} assigned
to agent A
2
and T = {T
i
}
2
i=1
. Notice that there are no
intra-agent precedence constraints, i.e., ≺
1
=≺
2
=
/
0.

Each individual agent A
i
receives a partially or-
dered set of tasks hT
i
, ≺
i
i and has to come up with
a plan to complete its set of tasks T
i
respecting the
set of constraints ≺
i
. We don’t need to know the ex-
act details of such plans, only the consequences w.r.t.
the ordering of the tasks in T
i
are important. There-
fore, we assume a plan of agent A
i
to be represented
by an arbitrary partial order ≺
∗
i
refining ≺
i
, i.e., a re-
lation that extends ≺
i
. A joint plan for T then is a
structure h{T
i
}
n
i=1
, ≺ ∪ ≺
∗
1
∪. . . ∪ ≺
∗
n
i. Clearly, such
a joint plan is infeasible if the relation ≺
∗
=≺ ∪ ≺
∗
1
1
To avoid trivial instances, we do assume that every task
t participates in at least some precedence constraint. If a
task set T would contain some isolated tasks, they can be
simply neglected.
2
Since package p
1
has to be first delivered from X to
location Y , and then it can be delivered to the final location
Z.
COORDINATING AGENTS - An Analysis of Coordination in Supply-chain Management Tasks
219

∪. . . ∪ ≺
∗
n
is not acyclic.
3
Example 2.2. Continuing Example 2.1, the agents
A
1
and A
2
receive the subtask hT
1
= {t
1
,t
2
}, ≺
1
=
/
0i
and hT
2
= {t
3
,t
4
}, ≺
2
=
/
0i, respectively. Suppose
they construct the following plans independently from
each other: A
1
comes up with a refinement ≺
∗
1
= {t
2
≺
t
1
}, while A
2
’s refinement is ≺
∗
2
= {t
3
≺ t
4
}. These
two refinements ≺
∗
1
and ≺
∗
2
, together with the prece-
dence relation ≺= {t
1
≺ t
3
,t
4
≺ t
2
}, create a cycle:
t
3
≺
∗
t
4
≺
∗
t
2
≺
∗
t
1
≺
∗
t
3
. Therefore, the joint plan is
infeasible. 
In general, a joint plan can become infeasible
since the individual constraints ≺
i
on the tasks T
i
given to the agents do not take into account the inter-
agent constraints t ≺ t
0
where t and t
0
belong to differ-
ent agents. Therefore, we have to come up with ad-
ditional constraints to ensure that whatever partially
ordered extensions of the individual precedence rela-
tions ≺
i
are chosen, their combination together with
the inter-agent constraints always constitutes a partial
order, i.e., a feasible plan for the complex task T .
Example 2.3. Continuing Example 2.2, let us give
an additional constraint t
1
≺ t
2
to agent A
1
. Notice
that now the subproblems of the two agents become:
hT
1
= {t
1
,t
2
}, ≺
1
= {t
1
≺ t
2
}i and hT
2
= {t
3
,t
4
}, ≺
2
=
/
0i. In this case, any feasible refinement of agent A
2
on ≺
2
will always constitute a partial order (feasible
solution) for T . 
So, we state the coordination checking problem as
follows: Given a coordination instance h{T
i
}
n
i=1
, ≺i
check whether every possible combination of partially
ordered refinements hT
i
, ≺
∗
i
i results in a joint plan
that is feasible, i.e., whether ≺
∗
=≺ ∪ ≺
∗
1
∪. . . ∪ ≺
∗
n
is acyclic. More in general, the coordination prob-
lem is to find a minimum set of additional precedence
constraints such that feasibility of the joint plan is al-
ways guaranteed. As mentioned before, these easy-
to-state pre-planning problems, however, turn out to
be computationally very difficult: Checking whether
a coordination instance T is already coordinated is
co-NP-complete and the problem to find a minimum
extension of ≺ that guarantees a coordinated solution
is Σ
p
2
-complete.
These results, however, do hold for the general
case. While special cases like constraining the num-
ber of agents or the number of tasks already have
been investigated (ter Mors, 2004), we would like to
investigate structurally restricted sub cases. Hence,
in the next section, we look into some special appli-
cations of the coordination problem, such as supply
3
A cycle in a plan would indicate that the plan can’t be
executed: completion of task t would need the completion
of another task t
0
and vice-versa.
chain management, showing that in these applications
it is often sufficient to consider instances of the coor-
dination problem where no precedence relations exist
between tasks given to the same agent. We call such
instances intra-free coordination instances.
3 SUPPLY CHAIN NETWORKS
Supply chain management is the management of ma-
terial and information flows both in and between en-
terprises (Kazemi et al., 2009). Figure 1 depicts a
simple supply chain network, where five different en-
terprises are involved: a product manufacturer, a cross
dock, a raw material supplier and two retailers. The
cross dock is an enterprise which does not produce
anything, but is simply involved in distribution of
products and raw materials. The flow of goods be-
tween the enterprises is indicated by the directed ar-
rows. Coordination in a supply chain network fo-
cusses on coordinating the activities and plans of the
individual enterprises involved in the supply chain.
Note here that we focus only on the topological task
structure and ignore all other factors such as costs,
time points, inventory levels.
The supply chain management problem has been
studied extensively in operations research (see (Chen
and Decker, 2004)), and some in the agent commu-
nity (Caridi and Sianesi, 2000; Kazemi et al., 2009).
Most research in this field, however, assumes that
each of the enterprises is either cooperative or owned
by a single enterprise. Hence a centralised optimiza-
tion solution can be used to solve the problem. How-
ever, situations commonly exist where enterprises are
selfish and non-cooperative. In such cases, our pre-
planning coordination approach provides an attractive
alternative for managing and coordinating the plans of
selfish enterprises in a supply chain network. The en-
tire set of activities in the supply chain network can be
represented as a partial order (T, ≺), where T repre-
sents the set of tasks (the nodes) and ≺ represents the
set of precedence relations (represented by directed
arcs). The enterprises are represented by agents each
having a set of tasks. The coordination problem now
is to find a minimum set of precedence constraints
such that each enterprise can plan its own activities
independently from the others, while the joint plan is
guaranteed to be feasible. As an example, a solution
to the particular instance in Figure 1 would be adding
a set of two coordination constraints: Send R
1
before
Send P
1
, P
2
; and Send R
2
before Send P
1
, P
2
. We can
easily check that these two coordination constraints
ensure that no cycles or deadlocks can be formed by
any plans generated individually by each enterprise.
ICAART 2010 - 2nd International Conference on Agents and Artificial Intelligence
220

Notice that there is an interesting feature in the
supply chain management problem as a coordination
problem: usually, an enterprise has no internal re-
strictions on its own activities or tasks.
4
To the en-
terprise, one advantage of having no internal (intra-
agent) precedence constraints is that the enterprise it-
self can enjoy the maximal freedom when planning its
own activities. As mentioned before, we call such an
instance intra-free. Notice that in intra-free instances,
each subgraph G
T
i
associated with the set of tasks al-
located to agent A
i
is the empty graph on V
T
i
, i.e., there
are no precedence relations between tasks assigned to
the same agent.
We show that for intra-free instances the coordi-
nation problems are computationally easier.
4 ANALYZING INTRA-FREE
COORDINATION INSTANCES
As we remarked before, in general, the coordination
(checking) problem is a computationally intractable
problem. Supply-chain like coordination problems,
however, can be modelled by intra-free coordination
instances and might be easier to solve. To start our
analysis, we define a special subclass of intra-free
coordination instances. We call it strictly intra-free,
which will be of special importance in proving prop-
erties of intra-free coordination instances:
Definition 4.1. An intra-free coordination instance
h{T
i
}
n
i=1
, ≺i is called strictly intra-free if, for every
i, the subset of (isolated) nodes V
T
i
of the graph G
T
can be partitioned in two disjoint subsets In(V
T
i
) and
Out(V
T
i
) such that In(V
T
i
) consists of nodes v with
outdegree 0 (out(v) = 0), also called sink nodes, and
Out(V
T
i
) consists of nodes v with indegree 0 (in(v) =
0), also called source nodes.
That is, in strictly intra-free coordination in-
stances, we exclude tasks t where both out(t) > 0 as
well as in(t) > 0. First, we will prove some results
for strictly intra-free coordination instances. Then we
will show that intra-free instances in general can be
easily reduced to strictly intra-free coordination in-
stances thereby proving that the properties holding
for strictly infra-free instances also hold for this larger
class of instances.
4
Note here that based on the policy of the manufacturer,
it could either choose to manufacture first or send products
first based on his inventory levels and its inventory policy.
Receive P
1
, P
2
Receive P
1
, P
2
Send P
1
Send P
2
Receive R
2
Receive R
1
Send R
1
Crossdock
Retailer 2
Retailer 1
Raw material supplier
Send P
1
, P
2
Manufacturer M
1
Send R
2
Send R
1
Send R
2
Make P
1
P
2
and
Figure 1: Example supply chain management scenario.
A1 A2
t1
t2
t3
t4
A1 A2
A1 A2
t1
t2
t3
t4
(a) Task graph (b) Agent dependency graph (c) A coordinated instance
Figure 2: The task graphs and their corresponding agent
dependency graph.
Given a partitioning {V
T
i
}
n
i=1
of the set of nodes
V
T
corresponding to the partitioning {T
i
}
n
i=1
, the co-
ordination checking problem comes down to decid-
ing whether for all possible acyclic extensions G
∗
T
i
=
hV
T
i
, E
≺
∗
i
i of the subgraphs G
T
i
= hV
T
i
,
/
0i the result-
ing extension G
∗
T
= hV
T
, E
≺
∪ E
≺
∗
1
∪ .. . ∪ E
≺
∗
n
i of G
T
is still acyclic. While the problem to decide whether
a given graph is acyclic is in P, the coordination prob-
lem is co-NP complete for general coordination in-
stances.
The rather surprising result we prove now is that
for (strictly) intra-free coordination instances, this co-
ordination checking problem can be reduced to check-
ing the acyclicity of an even (smaller) graph and
hence, this problem is in P as well.
Here, we need to introduce the agent depen-
dency graph G
A
derived from G
T
and the partitioning
{T
i
}
n
i=1
of T :
Definition 4.2 (Agent Dependency Graph). Given a
task graph G
T
and a partitioning {T
i
}
n
i=1
, the agent
dependency graph derived from G
T
is a graph G
A
=
(V
A
, E
A
), where V
A
= {v
A
i
: A
i
∈ A} is the set of nodes
corresponding to agents, and E
A
= {(v
A
i
, v
A
j
) : ∃t ∈
T
i
, ∃t
0
∈ T
j
, [t ≺ t
0
]} is the dependency relation be-
tween them.
Example 4.1. Consider the package delivery exam-
ple (Example 2.1) discussed in Section 2, where four
delivery tasks are allocated to two agents. Its task
graph is illustrated in Figure 2(a). Figure 2(b) shows
its corresponding agent dependency graph. 
COORDINATING AGENTS - An Analysis of Coordination in Supply-chain Management Tasks
221

There is a simple connection between coordina-
tion checking for T and acyclicity testing of G
A
:
5
Proposition 4.1. Let T = h{T
i
}
n
i=1
, ≺i be a coordina-
tion instance and G
A
its associated agent dependency
graph. Then G
A
is acyclic implies that T is coor-
dinated, i.e., T is a yes-instance of the coordination
checking problem.
In general, the converse of this proposition is not
true: even if G
A
is cyclic, we might have a yes-
instance of T .
Example 4.2. Consider the task graph shown in Fig-
ure 2(c). Clearly, this instance is coordinated. The
agent dependency graph, as shown in 2(b), however,
contains a cycle: each of the agents is dependent upon
the other as t
3
is dependent upon t
1
while t
2
is depen-
dent upon t
4
. 
However, if T = h{T
i
}
n
i=1
, ≺i is a strictly intra-
free coordination instance we can actually show that
the converse holds, too:
Theorem 4.2. Let T = h{T
i
}
n
i=1
, ≺i be a strictly
intra-free coordination instance and G
A
its agent de-
pendency graph. Then G
A
is acyclic iff T is a yes-
instance of the coordination checking problem.
Note that these results hold for strictly intra-
free coordination instances. It is, however, very
easy to generalize them to intra-free coordination in-
stances by polynomially reducing intra-free instances
to strictly intra-free instances: we apply the following
task-splitting procedure to tasks that violate the strict
intra-free property.
Given an arbitrary intra-free coordination instance
T = h{T
i
}
n
i=1
, ≺i, for every i and every t ∈ T
i
such that
in(t), out(t) > 0, do the following:
1. split t in two tasks t
1
and t
2
2. add all precedence constraints t
0
≺ t
1
such that t
0
≺
t and add t
2
≺ t
0
whenever t ≺ t
0
;
3. remove t and all precedence constraints it is men-
tioned in.
Clearly, the result is an equivalent strictly intra-free
coordination instance.
Example 4.3. A simple example in Figure 3 illus-
trates how to convert an intra-free instance to a
strictly intra-free instance. The task t of agent A
2
5
As space is limited, we have decided to omit all proofs
of the results stated in the paper. A simple email to one of
the authors is sufficient to obtain an extended version of the
paper containing all the proofs.
t
t
2
t
1
A
1
A
3
A
3
A
2
A
2
A
1
Figure 3: An intra-free coordination instance (first graph),
converted to a strictly intra-free instance (second graph).
has been split into two tasks t
1
and t
2
. We can sim-
ply verify that when the (converted) strictly intra-free
instance is coordinated, the (original) intra-free in-
stance must be also coordinated. 
Therefore, we obtain the following observation.
Observation 4.3. An intra-free coordination instance
T is coordinated whenever its strictly intra-free vari-
ant T
0
is coordinated.
Based on these results we can now perform coor-
dination checking in polynomial time: All we need
to do is to find out if the agent dependency graph of
the given intra-free instance is acyclic. This problem
is known to be solvable in polynomial time (Cormen
et al., 1990).
Given the fact that coordination checking for
intra-free instances is easy, one might hope that find-
ing a minimum coordination set is also tractable in the
case of intra-free coordination instances. This turns
out to be wrong. Finding such a minimum set of co-
ordination constraints is NP-hard as we have the fol-
lowing result:
Proposition 4.4. The NP-complete DIRECTED FEED-
BACK VERTEX SET problem is polynomially re-
ducible to the decision version of the minimum co-
ordination problem for intra-free coordination in-
stances.
Remark. In fact, it can be shown that the problem
whether K given coordination arcs are sufficient to
make an intra-free coordination instance coordinated
can be decided in polynomial time. This shows that
the problem is in NP, hence we can conclude that the
coordination problem for intra-free instances is NP-
complete.
4.1 An Approximation Algorithm
We can use the agent dependency graph and the re-
sults obtained in the previous sections to obtain an ap-
proximation algorithm for constructing coordination
sets in an easy way. The idea is, given an intra-free
coordination instance, first to find an (approximate)
minimum feedback vertex set V
0
for the associated
ICAART 2010 - 2nd International Conference on Agents and Artificial Intelligence
222

agent dependency graph and then to use this feed-
back vertex set V
0
to create a sufficient set of coor-
dination arcs by adequately blocking connections in
the corresponding task sets of agents occurring in V
0
.
This blocking can be realized by adding arcs from all
source to all sink tasks occurring in the task sets.
So the FVS-algorithm essentially consists of the
following steps:
1. Given a coordination instance h{T
i
}
n
i=1
, ≺i, cre-
ate the associated agent dependency graph G
A
=
hV
A
, E
A
i;
2. Find an approximation
6
of a minimum directed
feedback vertex set F ⊂ V
A
of G
A
. ;
3. For every v
A
i
∈ F, for every t ∈ Out(T
i
) (source
task) and for every t
0
∈ In(T
i
) (sink task), add the
coordination constraint t ≺
∗
i
t
0
thereby blocking
any cycle passing through tasks belonging to A
i
.
It can be easily shown that in most cases this algo-
rithm will outperform the existing depth partitioning
algorithm (Steenhuisen et al., 2008)
7
.
5 CONCLUSIONS AND FUTURE
WORK
This paper identified a new subclass of coordina-
tion problems called intra-free coordination instances
which have a relevance to model production and dis-
tribution planning problems in particular and supply
chain planning in general. We have shown that the
(decision version of the) plan coordination problem
for this subproblem is NP-complete, instead of the Σ
P
2
complexity of the general coordination problem. We
also proposed a specialized approximation technique
to design a ‘good’ set of coordination constraints in
polynomial time.
As part of our future research, first of all we are in-
vestigating better heuristics for producing subset min-
imal coordination sets e.g., as we have discussed in
the previous section, and we would like to refine the
theoretical performance comparison analysis based
upon them.
REFERENCES
Caridi, M. and Sianesi, A. (2000). Multi-agent systems in
production planning and control: An application to the
6
We can use any known approximation algorithm for
this problem.
7
Due to space limitations, we omit the performance
analysis in this paper.
scheduling of mixed-model assembly lines. Interna-
tional Journal of Production Economics, 68(1):29 –
42.
Chen, W. and Decker, K. (2004). Managing multi-agent co-
ordination, planning, and scheduling. In Autonomous
Agents and Multiagent Systems, 2004. AAMAS 2004.
Proceedings of the Third International Joint Confer-
ence on, pages 1360–1361.
Cormen, T. T., Leiserson, C. E., and Rivest, R. L. (1990).
Introduction to algorithms. MIT Press, Cambridge,
MA, USA.
Durfee, E. H. (1999). Distributed problem solving and
planning. In Weiß, G., editor, Multiagent Systems:
A Modern Approach to Distributed Artificial Intelli-
gence, pages 121–164. MIT Press, Cambridge, MA,
USA.
Durfee, E. H. and Lesser, V. R. (1991). Partial global plan-
ning: a coordination framework for distributed hy-
pothesis formation. IEEE Transactions on systems,
Man, and Cybernetics, 21(5):1167–1183.
Ephrati, E. and Rosenschein, J. S. (1993). Multi-agent plan-
ning as the process of merging distributed sub-plans.
In Proceedings of the Twelfth International Workshop
on Distributed Artificial Intelligence (DAI-93), pages
115–129.
Foulser, D., Li, M., and Yang, Q. (1992). Theory and algo-
rithms for plan merging. Artificial Intelligence Jour-
nal, 57(2–3):143–182.
Kazemi, A., Zarandi, M. F., and Husseini, S. M. (2009). A
multi-agent system to solve the productiondistribution
planning problem for a supply chain: a genetic algo-
rithm approach. International Journal of Advanced
Manufacturing Technilogy, 44:180–193.
Lesser, V., Decker, K., Wagner, T., Carver, N., Garvey,
A., Horling, B., Neiman, D., Podorozhny, R., Nagen-
draPrasad, M., Raja, A., Vincent, R., Xuan, P., and
Zhang, X. (2004). Evolution of the GPGP/TAEMS
Domain-Independent Coordination Framework. Au-
tonomous Agents and Multi-Agent Systems, 9(1):87–
143.
Steenhuisen, J. R., Witteveen, C., and Zhang, Y. (2008).
Plan-coordination mechanisms and the price of auton-
omy. In Sadri, F. and Satoh, K., editors, Computa-
tional Logic in Multi-Agent Systems, volume 5056 of
Lecture Notes in Artificial Intelligence, pages 1–21.
Springer-Verlag.
ter Mors, A. (2004). Coordinating autonomous planning
agents. Master’s thesis, TU Delft, Delft, The Nether-
lands.
Tonino, H., Bos, A., de Weerdt, M., and Witteveen, C.
(2002). Plan coordination by revision in collective
agent based systems. Artificial Intelligence, 142:121–
145.
von Martial, F. (1992). Coordinating Plans of Autonomous
Agents, volume 610 of Lecture Notes on Artificial In-
telligence. Springer Verlag, Berlin.
COORDINATING AGENTS - An Analysis of Coordination in Supply-chain Management Tasks
223