Scheduling and Negotiation Method for Double Synchronized
Multi-Agent Pickup and Delivery Problem
Yuki Miyashita
1 a
and Toshiharu Sugawara
2 b
1
Shimizu Corporation, 2-16-1 Kyobashi, Chuo-ku, Tokyo, Japan
2
Waseda University, 3-4-1 Okubo, Shinjuku-ku, Tokyo, Japan
Keywords:
Multi-Agent System, Scheduling, Synchronization, Sequential Cooperative Task, Contract Net Protocol.
Abstract:
We propose a multi-agent scheduling and negotiation method for pickup and delivery tasks, each of which
requires two synchronizations between heterogeneous agents. Real-world applications of multi-agent systems
often require synchronous cooperation at specific times while resolving conflicts between agents. Iterative
multi-agent path-finding problem has recently received much attention, which is called multi-agent pickup and
delivery (MAPD) problem. In the MAPD problem, agents move to the pickup locations, load materials, and
deliver them to their respective unloading locations, by repeatedly assigning new tasks to agents consecutively.
Our target is a multi-agent pickup and delivery (MAPD) problem in a multi-story building/warehouse, and
thus, a carrier agent requires synchronizations when loading and unloading materials in elevators. We call
this problem a double synchronized MAPD (DSMAPD). To our knowledge, the current studies in MAPD have
rarely considered such complicated tasks with synchronizations. Our proposed method attempts to reduce
the unnecessary free time to improve the efficiency and agents’ operating time without causing collisions
and disturbing already agreed-upon synchronizations. The experiments show that our method can outperform
naive methods for completing DSMAPD problem instances with reasonable planning and scheduling time.
1 INTRODUCTION
Many real-world applications of multi-agent systems
require that agents cooperate with other agents. The
examples of these applications include cooperative
routing of a truck-drone system (Luo et al., 2022;
Das et al., 2021), manipulation of elevators for robots
in multiple floors (Ge et al., 2021), and logistic
processes in open-pit mines (Ahumada and Herzog,
2021; Zhang et al., 2021). Our target applications
are transportation and packing of products in a multi-
story warehouse and transportation of heavy construc-
tion materials to work locations for next day’s task
during night by self-driving carriers and elevators.
In these applications, a robot (i.e., a carrier agent)
transports a material on a certain floor horizontally
and an elevator (an elevator agent) transports it verti-
cally. When the material should be delivered to an-
other floor level, the carrier agent carries it to an el-
evator and unloads it. Then, the elevator moves to
the destination floor, and another carrier agent on that
a
https://orcid.org/0000-0002-1676-9346
b
https://orcid.org/0000-0002-9271-4507
floor loads the material inside the elevator and carries
it to the required destination. This type of problem
should be executed by iteratively generating sched-
ules with two synchronizations between carrier and
elevator agents on different floors for the respective
tasks.
Therefore, these tasks can be considered as
a double synchronized multi-agent pickup-and-
delivery (DSMAPD) problem, which is an exten-
sion of the multi-agent pickup-and-delivery prob-
lem (MAPD) (Ma et al., 2017). The objective of
DSMAPD is that two types of cooperative agents
transport materials without collisions as efficiently as
possible.
Many studies have been conducted on the MAPD
problem so far, but most of them have focused on
generating collision-free paths to consecutively per-
form the pickup and delivery in a single floor, that
is, horizontal transportation (Sharon et al., 2015; Ma
et al., 2017; Yamauchi et al., 2022; Miyashita et al.,
2023; Okumura et al., 2022; Okumura, 2023). Al-
though in real-world applications agents are often
required to cooperate performing synchronized ac-
tions between independent and heterogeneous agents,
Miyashita, Y. and Sugawara, T.
Scheduling and Negotiation Method for Double Synchronized Multi-Agent Pickup and Delivery Problem.
DOI: 10.5220/0012390800003636
Paper published under CC license (CC BY-NC-ND 4.0)
In Proceedings of the 16th International Conference on Agents and Artificial Intelligence (ICAART 2024) - Volume 1, pages 321-332
ISBN: 978-989-758-680-4; ISSN: 2184-433X
Proceedings Copyright © 2024 by SCITEPRESS – Science and Technology Publications, Lda.
321

only few studies have focused on synchronized tasks
in MAPD. An exceptional study was conducted by
Zhang et al. (Zhang et al., 2022), in which they pro-
posed a mining truck system that realizes a consecu-
tive transportation of materials excavated by shovels
and hauled by trucks at some loading locations. How-
ever, their method is excessively simple for our tar-
get applications, which require double synchroniza-
tion between different pairs of heterogeneous agents,
simultaneously.
Therefore, we propose a scheduling and negotia-
tion method for the DSMAPD problem that enables
agents to generate an efficient schedule through ne-
gotiation to select appropriate cooperative agents for
the synchronized work. This method is an extension
of the contract net protocol (CNP) (Smith, 1980), and
a carrier agent on the start floor of a DSMAPD task
instance plays the role of the manager. Thus, it ini-
tiates the negotiation to determine the elevator agent
and the time and location of the first synchronization.
Then, after receiving the arrival time and location on
the destination floor, the manager agent further con-
tinues the negotiation with all carrier agents on that
floor to determine the time and location of the second
synchronization with the selected elevator.
One feature of the proposed method is that, be-
cause the schedules of an agent will likely involve free
time owing to the synchronization with other agents
and collision avoidance, new schedules are generated
so that unnecessary free (i.e., wasting) times are re-
duced as much as possible without disrupting the syn-
chronizations that have already been determined. In
naive methods, a new schedule is usually added at the
end of the schedule time to avoid disruption. In our
method, agents attempt to insert a new schedule into
the free time in the schedule timeline, while creating
the shortest collision-free paths using a certain multi-
agent path-finding algorithm such as cooperative A*
(CoopA
∗
) (Silver, 2005) to estimate the synchroniza-
tion time.
We evaluated our method in simulated experimen-
tal environments by comparing the results with those
obtained from the straightforward breadth-first-based
search to decide the cooperative agents and synchro-
nization time. The results indicate that our method
achieves considerably efficient and effective execu-
tions of DSMAPD problem instances without colli-
sions and deadlock/livelock situations. Finally, we
state the limitations of our method and propose future
extensions.
2 RELATED WORK
The combination of robot (vehicle) routing and
scheduling is used in many applications, and thus,
extensive studies have targeted this topic from these
applications (Fumero and Vercellis, 1999; Bredstr
¨
om
and R
¨
onnqvist, 2008; Ma et al., 2017). For exam-
ple, Ma et al. (Ma et al., 2017) proposed a prioritized
path planning method for the MAPD problem. Ku-
mar et al. (Kumar et al., 2023) introduced a mech-
anism to provide better flexibility for multiple selfish
agents while improving the total performance in a taxi
fleet problem. However, Ma et al. (Ma et al., 2017)
focused only on generating collision-free paths for
MAPD, and Kumar et al. (Kumar et al., 2023) targeted
a strategic and operational decision problem in which
agents maximize their profits (profit-maximization).
The problem of synchronized scheduling for hetero-
geneous agents has not received much attention in the
literature.
The synchronized scheduling of heterogeneous
agents has also been extensively studied (Zhang et al.,
2022; Kafle et al., 2017). Kafle et al. (Kafle et al.,
2017) proposed an urban parcel delivery system in
which the trucks respectively determine their routes
and schedules to coordinate with the cyclists and
pedestrians. Das et al. (Das et al., 2021) presented
a new mechanism that includes multiple vehicles
in cooperation with multiple drones that work syn-
chronously with trucks as mobile launching and re-
trieval sites for drones. In the process of open-
pit mines (Bastos et al., 2011; Alexandre et al.,
2017), Ahumada et al. (Ahumada and Herzog, 2021)
proposed multi-agent negotiation algorithms using a
contract net protocol in which agents interact with
each other to generate schedules for their represented
equipment item. Alexandre et al. (Alexandre et al.,
2017) presented a mathematical model for the multi-
objective (cost and production) truck dispatch prob-
lem in open-pit mining operations. However, their
method is too simple for our target applications,
which require two synchronizations between carrier
and elevator agents on different floors for their respec-
tive tasks at a construction site. Furthermore, some
types of agents can be a bottleneck of work due to
their small number. Therefore, we propose a schedul-
ing and negotiation method for the DSMAPD prob-
lem in which agents can generate synchronized sched-
ules for cooperative work without disrupting the syn-
chronizations that have already been determined as
well as reducing the unnecessary wasting period of
time.
ICAART 2024 - 16th International Conference on Agents and Artificial Intelligence
322

Figure 1: Example of multi-story building environment.
(a) Environment 1
(b) Environment 2
Figure 2: Example Environments for DSMAPD problems.
3 MODEL AND PROBLEM
3.1 Model of Agents and Environment
We formulate the DSMAPD problem on the basis
of our practical logistics scenario. The main differ-
ence from MAPD is that beside the delivery tasks in a
floor, tasks in DSMAPD requires synchronized coop-
eration between heterogeneous agents. Example in a
multi-story environment is shown in Fig. 1, in which
two types of agents in an environment execute tasks
of delivery orders performed through sequential co-
operation. The first type of agent, called a carrier
agent, has the role of loading a material, delivering
it horizontally to the given destination in a specified
floor, like the agent in MAPD. The second type of
agent, called an elevator agent, transports a material
vertically between floor levels. We assume that all
agents can transport only one material and an eleva-
tor agents does not transport a carrier agent to another
floor level.
A task in DSMAPD requires carrying material
from a floor (called the pickup floor) to the floor of the
destination point (the floor is called the delivery floor,
hereafter). If the pickup and delivery floors are the
same, a carrier agent execute it by loading a material,
carrying it, and unloading it in that floor. In contrast,
if the levels are different, cooperation among differ-
ent agents is necessary, that is, one carrier agent on
the pickup floor must carry the material to a meeting
point that can be reached by an elevator agent, the el-
evator must transport it to the delivery floor level, and
another carrier agent on the delivery floor must load
the material from the elevator at the meeting point,
carry it, and unload it at the destination point. Note
that each elevator agent has its own meeting points
on all floors where it can transport a material. There-
fore, this type of task consists of three subtasks that
should be executed sequentially with synchronization
by cooperation of two type of agents. the overall ob-
jective of DSMAPD is to accomplish effective coop-
erative transportation with reasonable computational
and communication cost and increase the throughput,
i.e. the number of executed tasks per unit of time.
The floor environments in Fig. 2 are described by
a grid consisting of N × N points (of intersection),
where a blue circle is a carrier agent, a green dia-
mond is an elevator agent, and a gray triangle is a
task endpoint, which is a pickup or delivery loca-
tion. A carrier agent takes one of the actions A
c
=
{N(orth), S(outh), E(ast), W(est), ST(ay), L(oad),
UN(load)}, whereas an elevator agent can move
to other floor levels by taking actions A
e
=
{U(p),D(own),ST(ay)}. When a carrier agent
loads/unloads a material into/from an elevator, it
moves to the point at which the elevator is located.
We do not consider the details of how to avoid con-
flicts, that is, collisions and deadlock situations, be-
cause some centralized/decentralized algorithms that
avoid conflicts between agents have already been pro-
posed (Sharon et al., 2015; Yamauchi et al., 2022; Ma
et al., 2017; Miyashita et al., 2023), and we assume
that one of them is used.
3.2 Problem Formulation
We introduce the discrete time t ≥ 0. Let I
c
=
{1,· ·· ,N} be the set of N carrier agents, I
e
=
{e
1
,· ·· ,N
E
} be the set of N
E
elevator agents, and
T = {τ
1
,· ·· ,τ
M
} be the set of M tasks required in
an environment, where N, N
E
, and M are positive in-
tegers. We assume that all tasks are given in ad-
vance and/or some tasks are added to T in real time.
Environment G consists of N
f
floors and the f -th
floor (where f ∈ F = {1,··· , N
f
}) is expressed by
graph G
f
= (V
f
,E
f
). Note that G
1
does not neces-
sarily indicate the ground floor of a multi-story build-
ing but rather the lowest floor. A location o
k
in G
is represented by ( f
k
,v
k
) ∈ F × V
f
k
, a pair of the
floor level and the location in that floor. A path is
denoted by a sequence of locations and time, p =
((o
1
,t
1
),. .., (o
n
p
,t
n
p
), where t
k
< t
k+1
, and o
i
and
o
i+1
indicate a horizontal move along an edge in the
same floor G
f
(i.e., f
i
= f
i+1
and (v
i
,v
i+1
) ∈ E
f
i
) or
Scheduling and Negotiation Method for Double Synchronized Multi-Agent Pickup and Delivery Problem
323

a vertical move at the same horizontal location (i.e.,
f
i
= f
i+1
+ 1 or f
i+1
− 1, and v
i
= v
i+1
). Therefore,
the path for a carrier agent consists only of horizon-
tal moves, whereas a path for an elevator consists of
vertical moves.
Task τ
k
∈ T is specified by tuple τ
k
= (o
p
k
,o
d
k
,µ
k
),
where µ
k
is the material to carry, while o
p
k
= ( f
p
k
,v
p
k
)
and o
d
k
= ( f
d
k
,v
d
k
) are the locations of the pickup and
delivery at which an agent loads to pick µ
k
up and
then it or another agent unloads to finally deliver µ
k
.
When f
p
k
= f
d
k
, τ
k
does not require vertical transporta-
tion and τ
k
should be executed by one carrier agent
on floor f
p
k
by moving along the horizontal path from
the current location to the delivery location o
d
k
via the
loading (pickup) location o
p
k
; such a task is called
a horizontal task. Otherwise, τ
k
requires coopera-
tion including vertical transportation of the material
from f
p
k
to f
d
k
by an elevator agent and the horizon-
tal transportation by two carrier agents on f
p
k
and f
d
k
.
Thus, this type of task is called a vertical task. To
achieve cooperative work for DSMAPD, we assume
that agents can communicate with each other by ex-
changing messages. The aim of our problem is that
all agents repeatedly perform sequential cooperation
to complete all the tasks as efficiently as possible.
A carrier agent can move to a neighboring lo-
cation in one timestep and load/unload in T
lu
(≥ 1)
timesteps. An elevator agent can move to a next level
from the current floor in T
f
(≥ 1) timesteps. We as-
sume that it takes more time for vertical movement
and loading/unloading than time for moving next lo-
cation.
3.3 Agents’ Schedule and Issues
One solution to achieve tailored cooperation would
be to set up and maintain the schedules of individ-
ual agents’ activities so that they are consistent with
those of other agents (Ahumada et al., 2020). In our
problem, timely synchronization is required for effi-
cient and effective work, i.e., an elevator agent should
arrive at approximately the same time as a cooperat-
ing carrier agent arrives at the meeting point and vice
versa. Furthermore, if the number of elevator agents is
relatively small, it is desirable for the carrier agents to
arrive at the meeting point slightly earlier. To achieve
these activities, each agent has its own schedule list
in order of time and must maintain the start and end
times of the assigned tasks so that all agents can work
coherently.
When agents maintain their schedule lists, a new
schedule for an assigned task will usually be added
to the end of schedule list, although this often causes
inefficiency; otherwise, the other agreed-upon (so ap-
proved) schedules in the list will be affected, and the
ensuing changes will further affect the other agents’
schedules in a cascading fashion. For example, in
DSMAPD, if a new schedule is put in the middle,
the starting location for the subsequent task will be
changed, and thus, the starting time for that task will
also change. This may cause a loss of synchroniza-
tion with other cooperative agents. Furthermore, to
avoid collisions, the path to the loading location will
change accordingly, which will affect the paths that
are already approved for other agents. Therefore,
we address this issue and propose a negotiation and
scheduling method to allocate the next task to an
agent for efficient cooperative task execution without
disturbing synchronization.
4 PROPOSED METHOD
The objective of DSMAPD is to accomplish effec-
tive cooperative transportation with reasonable com-
putational and communication cost and with effective
synchronization. In this section, we describe the pro-
posed scheduling and negotiation method in which
agents interact with other agents to create efficient
schedules for cooperation by incorporating advance
path-planning for a new task.
4.1 Scheduling Method
4.1.1 Schedule Element
Agent i takes actions according to the associated
schedule list S
i
= [s
i
1
,· ·· ,s
i
|S|
] whose element, called
schedule element (or simply, schedule) s
i
n
in S
i
is spec-
ified by s
i
n
= {t
s
n
,t
l
n
,t
e
n
,o
s
n
,o
l
n
,o
e
n
, p
sl
n
, p
le
n
,µ
k
,τ
k
},
where τ
k
is the task to execute in this schedule ele-
ment and µ
k
∈ τ
k
denotes a material requested to carry
in τ
k
. Parameter t
s
n
is the time when i starts moving
from the anticipated starting location, o
s
n
, to the load-
ing location, o
l
n
, along the planned path p
sl
n
. t
l
n
(> t
s
n
)
is the time when i starts moving from o
l
n
to its un-
loading location o
e
n
along the path p
le
n
after loading,
and t
e
n
(> t
l
n
) is the time when agent starts unloading
µ
k
at o
d
n
specified in τ
k
. We define the length of the
schedule element as (T
lu
+ t
e
n
) − t
s
n
. We introduce the
maximum time length, T
max
> 0, of the schedule list
to avoid scheduling in the distant future, i.e., agents
do not generate a schedule element whose end time
t
e
n
> t
c
+T
max
, where t
c
is the current time. Note that if
i is the carrier agent, s
i
n
must satisfy o
p
k
= o
l
n
or o
d
k
= o
e
n
(or both).
For the first element s
i
1
of S
i
, o
s
1
is the current lo-
cation and p
sl
1
is the path from o
s
1
to o
l
1
. Otherwise,
ICAART 2024 - 16th International Conference on Agents and Artificial Intelligence
324

(a)
t
s
t
l
t
e
t
s
n
t
l
n
t
e
n
s
i
n
s
i
(b)
t
s
1
t
l
1
t
e
1
t
s
n
t
l
n
t
e
n
t
s
t
l
t
e
t
s′
1
s
i
s
i
1
s
i
n
(c)
t
s
n
t
l
n
t
e
n
t
s
n
t
l
n
t
e
n
t
s
t
l
t
e
t
s′
n
s
i
n
s
i
s
i
n
−1
−1
−1
−1
Figure 3: Cases for adding a schedule.
p
sl
n
is the path whose start location o
s
n
is the desti-
nation of the previous schedule element, o
e
n−1
(or a
location where the agent i can stop temporarily by us-
ing a standby location (Yamauchi et al., 2022) near
o
e
n−1
). All paths, p
sl
n
and p
le
n
, must be collision-free
and are generated by an appropriate algorithm such as
cooperative A* (Silver, 2005) by referring to the ap-
proved (scheduled) paths of other agents. When all
paths and synchronizations of the new schedule ele-
ment have been approved after a negotiation process
(Section 4.2), it is stored in the schedule list. Note that
we assume that an elevator agent never collides with
other elevator agents because of the characteristics of
normal elevators. Any s
i
n
∈ S
i
whose t
e
n
is smaller than
t
c
is removed; this means that the first element of S
i
is the schedule for the current or next activity for task
execution. Moreover, when τ
k
is completed, it is re-
moved from T .
One main feature of our scheduling method is that
we retain the times for synchronizations, t
l
n
and t
e
n
in
s
i
n
∈ S
i
, if another schedule element is added to the
list. This avoids the cascade effects to the sched-
ules of other agents. We also allow inserting an-
other schedule element s
i
∗
before s
i
n
, if there is suf-
ficient time between s
i
n−1
and s
i
n
. This means that the
start time t
s
n
and the associated path p
p
n
could change
if a new schedule element is inserted; the details of
how another schedule is inserted are described in Sec-
tion 4.1.2.
Initially (t = 0), agent i ∈ I (= I
c
∪ I
e
) starts from
the initial location, and it keeps stays there until t = t
s
1
,
where t
s
1
is the start time of the first schedule element
s
i
1
(∈ S
i
). Then, i starts moving to o
l
1
along p
l
1
at t
s
1
in s
i
1
. We assume that carrier agent i
c
∈ I
c
begins to
load/unload inside i
e
∈ I
e
after the cooperating ele-
vator agent i
e
has arrived at the meeting location on
the same floor. Note that agent i cannot stop in the
middle of its movement to the next location/floor. Af-
ter completing the transportation specified by s
i
1
, s
i
1
is removed from S
i
, and then i moves on to the next
schedule, s
i
1
, which was the second schedule s
i
2
before
removing the previous s
i
1
.
4.1.2 Incorporating New Schedule Elements
Because DSMAPD tasks require synchronization
with other agents and this is considered as a con-
straint, the time space between schedule elements
may not be completely filled, and long blank peri-
ods of time with no work may arise. Therefore, an
agent should consider to add a new schedule between
the existing schedule elements to shorten unneces-
sary waiting periods as long as it does not disrupt
the scheduled synchronized activities. However, be-
cause the actual scheduling time can only be deter-
mined after a negotiation with the cooperating agents,
the agent has to identify as many as possible schedul-
ing times for reaching an agreement with them. Note
that the loading and/or unloading locations o
l
and/or
o
e
are determined in advance because they are in the
part of the new task τ = (o
p
,o
d
,µ).
When agent i adds a new schedule element s
i
=
{t
s
,t
l
,t
e
,o
s
,o
l
,o
e
, p
sl
, p
le
,µ, τ} to a possible time
interval, we can consider three possible cases, as
shown in Fig. 3, in which the horizontal bars represent
the start and end times of schedule elements in the
current schedule list, the blue boxes represent the ex-
isting schedules, and the green boxes are new sched-
ule elements that i tries to add to the schedule list. In
the first case (Case (a)), i will add the new schedule to
the end of the list. In Cases (b) and (c), i tries to add
it before a schedule element that is already approved.
We assume that the loading and unloading locations,
o
l
and o
e
, are also determined when i is required to
schedule for a cooperative task.
Case (a): Agent i can set the synchronization time
later because it has no subsequent scheduled activi-
ties. That is, i can insert the new schedule element
s
i
at the end of S
i
by setting t
s
= t
e
n
0
+ T
lu
(where
n
0
= |S
i
|). Then, i can generate a collision-free path
p
sl
from o
s
(= o
e
n
0
) to the loading location o
l
for τ
and thus can determine its (earliest) loading time t
l
ear
.
Next, i generates a collision-free path p
le
from o
l
k
at
t
l
ear
+ T
lu
to o
e
and can determine the earliest unload-
ing time t
e
ear
, which is the possible earliest time of t
e
in the new schedule element. Then, suppose that i is
a carrier agent. By introducing the maximal interval
size L > 0, if o
l
is the synchronization location, the
possible synchronization time can be [t
l
ear
,t
l
ear
+ L]. If
o
e
is the synchronization location, the possible syn-
chronization time can be [t
e
ear
,t
e
ear
+L]. If i is an eleva-
tor agent, i will first select the synchronization time t
l
from [t
l
ear
,t
l
ear
+L] through a negotiation, as discussed
in Section 4.2.
Case (c): We now consider Case (c) (Case (b)
is a special case of Case (c)). In Case (c), i decides
whether s
i
can be inserted between s
i
n−1
and s
i
n
. First,
Scheduling and Negotiation Method for Double Synchronized Multi-Agent Pickup and Delivery Problem
325

Figure 4: Interaction between agents.
i builds a collision-free path p
sl
starting from o
e
n−1
at t
e
n−1
to o
l
and then i can determine the earliest time
t
l
ear
to arrive at o
l
moving along p
sl
. Next, i builds
path p
le
starting from o
l
at t
l
+ T
lu
to o
e
. Then, us-
ing p
sl
, i can determine the earliest time t
e
ear
when i
reaches o
e
. Subsequently, i also creates another ˜p
sl
from o
e
at t
e
ear
+ T
lu
to o
l
n
so that i arrives there before
t
l
n
; if i cannot create such a path, i renounces to insert
s
i
between s
i
n−1
and s
i
n
.
If i is a carrier agent, it attempts to load/unload µ
synchronizing with an elevator agent. The time inter-
val of the possible synchronization times can be cal-
culated by considering the earliest and latest loading
or unloading time t
l
ear
and t
e
ear
; the details of algorithm
are presented in Alg. 1 and Alg. 2. If i is an elevator
agent, because i requires the synchronization at two
locations, o
l
and o
e
, two resulting time intervals in
FindSyncTime(i, s
n
,t
s
,o
s
,o
l
,o
e
) are used.
Case (b): By setting t
s
= t
c
(current time) and o
s
=
o
i
c
(i’s current location), we can identify Case (b) from
Case (c). For example, if i is the elevator agent, i can
determine them by FindSyncTime(i,s
1
,t
c
,o
i
c
,o
l
,o
e
),
where s
1
is the first element of S
i
. Note again that
loading and unloading locations o
l
and o
e
are auto-
matically determined depending on the synchroniza-
tion with agent i.
4.2 Negotiation Process
To perform a task in DSMAPD that includes both ver-
tical and horizontal transportation, we propose a task
negotiation process by extending the CNP. Figure 4
shows the entire flow of the negotiation process be-
tween two carrier agents on different floors and one
elevator agent for a DSMAPD task.
A carrier agent i that is not negotiating with other
agents and whose time length from t
c
to the last ele-
ment in the schedule list is shorter than the threshold,
T
max
(> 0), selects one task τ = (o
p
,o
d
,µ) ∈ T whose
pick up floor is identical to i’s floor. If τ is horizontal
task, i adds the schedule element s
i
τ
for τ somewhere
in its schedule list S
i
without using a negotiation pro-
cess and following the method in Section 4.1.2. If i
can insert s
i
τ
into multiple time slots, i selects the time
slot whose start time t
s
τ
is the earliest.
4.2.1 Negotiation with Elevator Agents
If f
p
6= f
d
, carrier agent i, which is shown as
“Carrier i” in Fig. 4, also works as the man-
ager agent to construct the group of cooperative
agents for τ and it decides its own schedule s
i
τ
=
{t
s,i
τ
,t
l,i
τ
,t
e,i
τ
,o
s,i
τ
,o
l,i
τ
,o
e,i
τ
, p
sl,i
τ
, p
le,i
τ
,µ
τ
,τ} by deter-
mining the time to synchronize with the appropriately
selected elevator agent and unload µ in floor f
p
. For
this purpose, i initiates the negotiation with all ele-
vator agents in I
e
. First, i sends them offer messages
that contain the current τ and the set of the possible
delivery time slots S
UTI
, which is the set of possible
intervals of time in which i can deliver the material τ
to the location of each elevator; this means that it is
also the set of possible times for synchronization be-
tween them. These time intervals can be calculated by
considering Cases (a) to (c) and using the method de-
scribed in Section 4.1.2. Note that the unload location
o
e,i
is different for each elevator i
e
∈ I
e
because o
e,i
is
the loading location o
l,i
e
τ
= ( f
p
,v
i
e
) of the cooperating
elevator agent i
e
.
After receiving the offer message from i, eleva-
tor agent i
e
decides whether it can create the synchro-
nized schedule by referring to its content. Therefore,
i
e
invokes the method in Section 4.1.2 to find the com-
mon synchronization times (CSTs) for loading µ by
calculating possible pickup time slots of i
e
. We de-
note this set of CSTs between i and i
e
by S
CST
i,i
e
. If i
e
can find them, it sends back to i an acceptance mes-
sage with S
CST
i,i
e
and the time c
le
i
e
required for e to
travel from f
p
to the delivery floor f
d
. The value c
le
i
e
is used to calculate the CST for unloading µ at f
d
.
Otherwise, it returns a refusal message (Fig. 4). Note
that if i
e
receives multiple offer messages at the same
time, i
e
sends the acceptance message to one carrier
agent i with which i
e
has the best possibilities for syn-
chronization, that is, S
CST
i,i
e
is the largest. If i
e
is
participating in another negotiation in which i
e
is still
waiting for the answer from a carrier, i
e
also returns a
ICAART 2024 - 16th International Conference on Agents and Artificial Intelligence
326

Algorithm 1: Find synchronization time (Case (c)).
Function FindSyncTime(i, s
n
,t
s
,o
s
,o
l
,o
e
):
In: i: Agent, s
n
: n-th element in the schedule list
// Agent i tries to insert a new schedule element between s
n−1
and s
n
In: t
s
: Earliest start time (= t
e
n−1
); o
s
: the endpoint o
e
n−1
in s
n−1
; o
l
, o
e
: Required (un)load locations
Generate the shortest collision-free path p
sl
from o
s
at t
s
to o
l
by using e.g., CoopA
∗
;
t
l
ear
← the earliest arrival time to o
l
by moving along p
sl
.;
Generate the shortest collision-free path p
le
from o
l
at t
l
ear
+ T
lu
to o
e
;
t
e
ear
← the time when i arrives o
e
along p
le
.;
Generate the shortest collision-free path ˜p
sl
from o
e
at t
e
ear
+ T
lu
to o
l
n
in s
n
;
if i arrives at o
l
n
at or after t
l
n
then return nil // Fail to insert
;
if if the synchronization location is the place to unload then
return Time interval from t
e
ear
to LatestStartTime(i,o
e
,t
e
ear
+ T
lu
,o
l
n
,t
l
n
) − T
lu
;
else
t
s
= LatestStartTime(i,o
e
,t
e
ear
+ T
lu
,o
l
n
,t
l
n
) − T
lu
;
return Time interval from t
l
ear
to LatestStartTime(i,o
l
,t
l
ear
+ T
lu
,o
e
,t
s
,);
end
Algorithm 2: Decide the latest start time.
Function LatestStartTime(i, o
1
,t
1
,o
2
,t
2
):
In: i: agent; o
1
: start location
In: t
1
: earliest possible start time from o
1
In: o
2
: destination; t
2
due time to o
2
// Agent i tries to decide the latest time to
// start from o
e
to o
l
n
before t
l
n
in s
n
.
L > 0: Upper limit of interval length;
for t = t
1
to t
1
+ L do
if if i can create a collision-free path
from o
e
to arrive at o
l
n
earlier than t
l
n
then
do nothing
else
return t − 1 // Latest time
end
end
return t
1
+ L // Latest time defined by L.
refusal message; then, i decides that the current nego-
tiation for τ has failed and declines to perform it.
After agent i receives all responses from the eleva-
tor agents, i determines the best acceptance response,
which is the largest S
CST
i,i
e
, from the elevator agent i
e
.
Next, i sends rejection messages to the other elevator
agents, and the elevator agents receiving the rejection
messages finish negotiation with i. Then, i generates
the schedule s
i
τ
so that its unloading time is the earli-
est in S
CST
i,i
e
. If i receives no acceptance messages, it
finishes the negotiation for τ and sends the rejection
messages to all elevator agents.
4.2.2 Negotiation with Carrier Agents on
Delivery Floor
Next, manager agent i starts the negotiation with car-
rier agents I
d
on the delivery floor f
d
(these agents are
shown as “Carriers d” in Fig. 4). Before starting it,
i calculates the set of possible synchronization times,
S
CST
i
e
,I
d
with carrier agents on f
d
by considering c
le
i
e
and S
CST
i,i
e
. Then, i starts to negotiate with carrier
agents i
d
on f
d
by sending them offer messages with
S
CST
i
e
,I
d
and the location to synchronize with i
e
on f
d
,
which is naturally determined based on i
e
with which
it is cooperating.
After receiving this offer message, agent i
d
de-
cides whether it can create the schedule including
synchronization. If i
d
can find the CSTs, S
CST
i
e
,i
d
,
to load µ from i
e
using the method presented in Sec-
tion 4.1.2, it sends back to i an acceptance message
with only the earliest loading time, t
l
ear
,i
d
in S
CST
i
e
,i
d
;
otherwise, it returns a refusal message. If i
d
is already
negotiating with other agents, i
d
also returns a refusal
message.
After manager agent i receives all the responses
from I
d
, i determines the best acceptance message
with the earliest t
l
ear
,i
d
from agent i
d
and sends rejec-
tion messages to the others. Then, i calculates the
earliest load time t
l
ear
,i
(= t
l
τ
in s
i
τ
) and earliest unload
time t
e
ear
,i
(= t
u
τ
) backwards from t
l
ear
,i
d
using c
le
i
e
to
decide its schedule s
i
τ
. Note that the other parameter
values in s
i
τ
are naturally decided based on the coop-
erating elevator agent i
e
. If i cannot receive any ac-
ceptance messages, i sends rejection messages to the
Scheduling and Negotiation Method for Double Synchronized Multi-Agent Pickup and Delivery Problem
327

selected elevator i
e
, and i finishes this negotiation for
τ. After receiving the rejection message, agent i
e
also
finishes the negotiation with i.
Subsequently, i, which is also a carrier agent on
floor f
p
, adds s
i
τ
to its schedule list S
i
as the ap-
proved schedule element and sends the contract mes-
sages with i
e
’s loading time t
l
i
e
(= t
u
i
) and unload time
t
e
i
e
(= t
l
ear
,i
d
) to the elevator agent i
e
and carrier i
d
. Fi-
nally, the agents receiving the contract messages from
the manager agent insert s
i
e
τ
and s
i
d
τ
into their own
schedule list as the approved elements. Then, the ne-
gotiation process ends.
4.2.3 Remark
We assume that our environment holds the condition
min
f ∈F
|{i
c
∈ I
c
| i
c
on floor f }| > |I
e
/2|. (1)
to prevent a deadlock/livelock during the negotiation
process. If we assume that the number of carrier
agents on each floor is the same, then this condition
can be
|I
c
|/|F| > |I
e
/2|, (2)
We explain the possibility of a livelock situation using
a simple example in which the environment consists
of two floors, two carrier agents on each floor, and
four elevator agents. Suppose that all carrier agents
start to negotiate with elevator agents to deliver ma-
terials at all floor levels. After this, all carrier agents
will receive acceptance messages from elevators and
then send offer messages to carrier agents on the de-
livery floors. Because all carrier agents have already
started a negotiation, they return refusal messages,
and thus, they also receive refusal messages. Then,
they simultaneously restart negotiation processes but
these will also result in failure. However, our assump-
tion is plausible and realistic in actual applications be-
cause the number of elevator is usually small, and it
could stop some elevators to hold Condition (2).
5 EXPERIMENTS AND
DISCUSSION
5.1 Experimental Setting
We evaluated the proposed method using DSMAPD
instances under two different environments and com-
pared the results with those using the synchronized
schedule searching algorithm (SSS) as a baseline,
which will be briefly explained in Section 5.2.
Our experiments were conducted in the two envi-
ronments shown in Fig. 2. In the first environment
Table 1: Experimental parameter values.
Parameter description and symbol Value
Size of environment, N 7
Number of tasks, M = |T | 30
No. of carrier agents in each floor, N
C
4 to 11
No. of elevator agents, N
E
6
No. of floors, N
f
4
Maximum length of schedule list, T
max
50
Upper limit of search time, L 50
Duration for moving to a next floor, T
f
4
Duration for loading/unloading, T
lu
2
Negotiation process per timestep, C 4
Upper limit of the length of instance, H 400
(Env. 1), each floor, as shown in Fig. 2a, had seven
task endpoints (gray triangles) that could be load and
unload locations of tasks, and eight elevator agents
(green diamonds) where carrier agents (black circles)
could load or unload materials. For simplicity, all
floors in the building (Fig. 1) had the same structure
as shown in Fig. 2a. In Env. 1, the elevators were
arranged in two rows because actual transport eleva-
tors are usually installed together in a building. In
the second environment (Env. 2), each floor also had
seven task endpoints and eight elevators, but their lo-
cations were placed randomly, as shown in Fig. 2b.
This scheme was used to investigate the performance
of the proposed method in general cases.
Both environments consisted of N
f
(> 0) floors,
the initial locations of N
C
(> 0) carrier agents on each
floor were randomly placed, and N
E
(> 0) elevators
were placed on randomly selected floors. Here, the
number of carrier agents on each floor was the same,
thus |F| × N
c
= |I
c
|. We assume that |T | is constant
M, and if one task is completed, it is removed from
T and another randomly generated task is added to
T . Agents continue to execute tasks until H > 0
timesteps; this experiment until H is an instance of
an experimental run. Then, another experimental run
starts after placing endpoints, agents, and elevators
randomly.
We introduced the factor C > 0 for the ratio of
communication time (with acknowledgement) to one
timestep in which any carrier agent can move to a
neighboring point. Usually, the physical movement
takes relatively a much longer time than that required
for communication with the associated computational
processing, but we set for it a relatively large value,
that is, C = 4, so that agents can confirm the received
messages, select one task to cooperate, and send/reply
messages to negotiate in 1/C timestep. Therefore,
agents can negotiate with other agents C times in one
timestep to attempt to generate a synchronized sched-
ICAART 2024 - 16th International Conference on Agents and Artificial Intelligence
328

ule but in parallel; thus, several negotiation processes
for generating schedules can be performed simultane-
ously.
For evaluation, we measured the number of com-
pleted tasks and the total CPU time in an experimen-
tal instance. The number of completed tasks indicates
the transportation efficiency, whereas the total CPU
time indicates the planning efficiency including com-
munication time. We list other parameter values in
Table 1. All experimental data are the average of 30
independent trials using an Apple M1 Max CPU with
64 GB RAM.
5.2 Baseline Method
To evaluate the performance of our proposed meth-
ods for DSMAPD, we implemented the synchronized
schedule search algorithm (SSS) as baseline because
we could not find conventional studies for double syn-
chronized tasks like ours. We briefly explain the SSS
in this section.
SSS is a breadth first search algorithm that starts
from the centralized root node with a DSMAPD task,
τ = (o
p
,o
d
,µ), and generates the lower (child) nodes,
which correspond to carrier agents on floor f
p
, and
all the nodes are simultaneously requested to calcu-
late the earliest delivery (unload) time after the al-
ready scheduled activities in the scheduled list. This
is performed by generating the shortest collision-free
path using CoopA
∗
by sharing the already approved
schedule elements on floor f
p
. Therefore, we do not
consider an insertion between the already scheduled
elements to avoid a cascade of conflicts. Then, imme-
diately upon receiving a reply (i.e., in the arrival or-
der of replies), the root node generates the next lower
nodes, which correspond to elevator agents, below
each carrier agent node and request them to find the
earliest synchronization time to load the material car-
ried by the upper node agent. Finally, it determines
the earliest arrival time at floor f
d
and returns the re-
sults to the root node.
In the same way, upon receiving a reply from an
elevator agent, the root node generates the further
lower nodes, which corresponds to the carrier agents
on f
d
, and requests them to decide the shortest path
to the corresponding elevator agents and the earliest
loading time inside the elevator. The reply to this re-
quest can generate the complete schedules. Then, the
root node assigns τ to the agents that return the earli-
est reply.
We assume that the SSS algorithm can generate
the agents’ synchronized schedules for a task in one
timestep although it requires many messages between
agents, and this assumption is a slight advantage over
the baseline. Therefore, for comparison, we also im-
plemented a more efficient baseline and called it dou-
ble SSS, which can generate synchronized schedules
for two tasks in one timestep. We will show that our
method is still more efficient than the baseline meth-
ods under this assumption.
5.3 Performance Comparison
5.3.1 Number of Executed Tasks
Figure 5 plots the average number of completed tasks
per experimental instance with different numbers of
carrier agents and six elevator agents. In Env. 1,
Fig. 5a indicates that the proposed method outper-
formed the baselines, SSS and double SSS, in any
cases with different numbers of carrier agents. For
example, the proposed method increased the number
of completed tasks by approximately 21% and 11%
over those of SSS and double SSS, when the number
of carrier agents on each floor was N
C
= 11.
In the baseline methods, new schedule elements
were added at the end of the agents’ schedule lists to
prevent potential conflicts with the approved schedule
elements. In particular, when the number of carrier
agents was relatively large compared to that of the el-
evator agents, many schedule elements were added to
the lists of the elevator agents, thus forcing them to
defer many synchronization times. By contrast, be-
cause agents with the proposed method could insert
new schedule elements between the approved sched-
ule elements, they could reduce the wasted free time
and could execute tasks more efficiently. In Env. 2,
as shown in Fig. 5b, with the proposed method the
agents could also improve the performance more than
with the baseline methods. Therefore, we consider
that our proposed method can achieve efficient trans-
portation for DSMAPD in more general cases.
5.3.2 Planning CPU Time
We also investigated the averaged planning CPU time
for all agents per instance with a different number of
carrier agents in Env. 1. The result is plotted in Fig. 6.
As can be observed, the planning time of SSS is much
smaller than those of other methods regardless of the
number of agents. Actually, compared to the pro-
posed method, SSS reduced the planning time by ap-
proximately 62% when N
C
= 4 and by approximately
42% when N
C
= 11. This was achieved because SSS
generated schedule elements in each agent by simply
adding them at the end of the schedule list, starting
or ending at the synchronization point and time. All
conflicts (i.e., collision in our experiments) could be
avoided by CoopA
∗
.
Scheduling and Negotiation Method for Double Synchronized Multi-Agent Pickup and Delivery Problem
329

(a) Env. 1 (b) Env. 2
Figure 5: Number of completed tasks.
Figure 6: Planning time per instance (second) in Exp. 1.
This figure also reveals that the planning time
with the proposed method was longer than that with
the other methods when the number of agents was
N
C
< 8, but the planning time with double SSS be-
came longer than that with the proposed method when
N
C
≥ 8. In double SSS, after an agent generated syn-
chronized schedules for the first task, the root node
attempted to generate synchronized schedules for the
second task. To generate synchronized schedules for
the second task, it was forced to search a larger num-
ber of nodes than those in the first task because it
found the synchronized time with less wasting time
right after the schedule for the first task. Therefore,
the computational cost was higher than that with SSS
and the proposed method. Although we omit the fig-
ure for the averaged planning CPU time in Env. 2, a
similar tendency was observed.
5.4 Discussion
The proposed method outperformed the baseline
methods (SSS and double SSS) in two environments
regardless of the number of carrier agents. To inves-
tigate the factors contributing to the performance, we
Table 2: Occupancy rate of agents (%).
Number of carrier agents N
c
Algorithm 4 5 6 7 8 9 10 11
Elevator agent
Proposed .87 .91 .93 .95 .96 .97 .97 .98
SSS .78 .84 .88 .90 .91 .92 .93 .93
double SSS .81 .87 .90 .92 .93 .94 .95 .96
Carrier agent
Proposed .76 .71 .64 .58 .52 .48 .43 .39
SSS .67 .60 .54 .49 .44 .39 .36 .33
double SSS .69 .64 .58 .52 .48 .43 .39 .36
analyzed the occupancy rate of agents’ schedules with
different numbers of agents in Env. 1 and list the re-
sults in Table 2, where the high rate means that the
cumulative waiting time between schedule elements
in one experimental instance is small. Table 2 indi-
cates that the occupancy rates of elevator and carrier
agents with the proposed method were always higher
than those of agents with the baselines, probably be-
cause the elevator agents with the proposed method
could avoid long free periods of time. This is the rea-
son for the higher efficiency of the proposed method.
The table also indicates that the occupancy rates
of elevator agents increased with increasing number
of carrier agents regardless of the method employed,
whereas the rates of the carrier agents decreased. Be-
cause the number of elevator agents is fixed and rela-
tively small, the number of offer messages from car-
rier agents increased and naturally the waiting peri-
ods of elevator agents decreased. In contrast, the offer
messages from the carrier agents became likely to be
refused because of the simultaneous offer messages
to elevator agents, and thus, the carrier agents lost
the possibility to add new schedules, causing the rela-
tively longer free time. This also means that elevator
ICAART 2024 - 16th International Conference on Agents and Artificial Intelligence
330

agents are the bottleneck of performance. However,
in actual applications, it is more difficult to increase
the number of elevators owing to the much higher cost
and effort required for their installation.
Interestingly, we found that the planning time of
double SSS exceeded that of the proposed method
when N
c
≥ 8. Furthermore, the difference in plan-
ning time between SSS and the proposed method be-
came gradually smaller with an increase in the num-
ber of carrier agents N
c
. This occurs because the
baseline methods need to generate a larger number of
lower (child) nodes as the number of carrier agents
increase, and thus, the root node in SSS and double
SSS is required to visit all the nodes before moving
on to the nodes at the next depth level. This discus-
sion also suggests that many messages are necessary
in the baseline methods. Meanwhile, agents using the
proposed method could discriminate better proposals
from appropriate agents through negotiation, and this
resulted in higher efficiency and fewer messages.
5.5 Conclusion
We propose a scheduling and negotiation method for
tasks that require double synchronization between
heterogeneous agents. To achieve efficient task exe-
cutions, our method enables agents to generate their
schedule by determining the effective synchroniza-
tion times and reducing the unnecessary idle time
through a negotiation process, which is an extension
of the CNP. It also decides the appropriate coopera-
tive agents step by step, thus reducing the number of
messages during the negotiation process. We exper-
imentally showed that the proposed method outper-
formed the baseline methods, SSS and double SSS,
for DSMAPD problem instances. It also involved a
reasonable computational cost in environments where
many agents are required to cooperate with other
agents to complete DSMAPD tasks.
In the future, we plan to extend our method to
more complex tasks, such as tasks that need more
synchronization times and locations and tasks that
have their own deadlines. Another extension is that
for tasks in which agents cannot move at a con-
stant speed. We also want to integrate our method
with one of the recent path-finding algorithms for
MAPD (Sharon et al., 2015; Ma et al., 2017; Ya-
mauchi et al., 2022; Okumura et al., 2022; Miyashita
et al., 2023).
REFERENCES
Ahumada, G. I. and Herzog, O. (2021). Application of
multiagent system and tabu search for truck dispatch-
ing in open-pit mines. In 0001, A. P. R., Steels,
L., and van den Herik, H. J., editors, Proceedings
of the 13th International Conference on Agents and
Artificial Intelligence, ICAART 2021, Volume 1, On-
line Streaming, February 4-6, 2021, pages 160–170.
SCITEPRESS.
Ahumada, G. I., Riveros, E., and Herzog, O. (2020). An
agent-based system for truck dispatching in open-pit
mines. In ICAART (1), pages 73–81.
Alexandre, R. F., Campelo, F., and Vasconcelos, J. a. A.
(2017). Multiobjective evolutionary algorithms for
operational planning problems in open-pit mining. In
Proceedings of the Genetic and Evolutionary Com-
putation Conference Companion, GECCO ’17, pages
259–260, New York, NY, USA. Association for Com-
puting Machinery.
Bastos, G. S., Souza, L. E., Ramos, F. T., and Ribeiro, C.
H. C. (2011). A single-dependent agent approach for
stochastic time-dependent truck dispatching in open-
pit mining. In 2011 14th International IEEE Con-
ference on Intelligent Transportation Systems (ITSC),
pages 1057–1062.
Bredstr
¨
om, D. and R
¨
onnqvist, M. (2008). Combined vehi-
cle routing and scheduling with temporal precedence
and synchronization constraints. European Journal of
Operational Research, 191(1):19–31.
Das, D. N., Sewani, R., Wang, J., and Tiwari, M. K. (2021).
Synchronized truck and drone routing in package de-
livery logistics. IEEE Transactions on Intelligent
Transportation Systems, 22(9):5772–5782.
Fumero, F. and Vercellis, C. (1999). Synchronized develop-
ment of production, inventory, and distribution sched-
ules. Transportation science, 33(3):330–340.
Ge, H., Matsui, M., and Koshizuka, N. (2021). An open-iot
approach on elevator for enabling autonomous robotic
vertical mobility. In 2021 IEEE 3rd Global Confer-
ence on Life Sciences and Technologies (LifeTech),
pages 139–141.
Kafle, N., Zou, B., and Lin, J. (2017). Design and model-
ing of a crowdsource-enabled system for urban parcel
relay and delivery. Transportation Research Part B:
Methodological, 99:62–82.
Kumar, R. R., Varakantham, P., and Cheng, S.-F. (2023).
Strategic planning for flexible agent availability in
large taxi fleets. In Proceedings of the 2023 Interna-
tional Conference on Autonomous Agents and Multia-
gent Systems, AAMAS ’23, pages 552–560, Richland,
SC. International Foundation for Autonomous Agents
and Multiagent Systems.
Luo, Q., Wu, G., Ji, B., Wang, L., and Suganthan, P. N.
(2022). Hybrid multi-objective optimization approach
with pareto local search for collaborative truck-drone
routing problems considering flexible time windows.
IEEE Transactions on Intelligent Transportation Sys-
tems, 23(8):13011–13025.
Ma, H., Li, J., Kumar, T. S., and Koenig, S. (2017). Life-
long multi-agent path finding for online pickup and
Scheduling and Negotiation Method for Double Synchronized Multi-Agent Pickup and Delivery Problem
331

delivery tasks. In Proceedings of the 16th Conference
on Autonomous Agents and MultiAgent Systems, AA-
MAS ’17, pages 837–845, Richland, SC. International
Foundation for Autonomous Agents and Multiagent
Systems.
Miyashita, Y., Yamauchi, T., and Sugawara, T. (2023). Dis-
tributed planning with asynchronous execution with
local navigation for multi-agent pickup and delivery
problem. In Proceedings of the 2023 International
Conference on Autonomous Agents and Multiagent
Systems, pages 914–922.
Okumura, K. (2023). Lacam: Search-based algorithm
for quick multi-agent pathfinding. Proceedings
of the AAAI Conference on Artificial Intelligence,
37(10):11655–11662.
Okumura, K., Machida, M., D
´
efago, X., and Tamura, Y.
(2022). Priority inheritance with backtracking for iter-
ative multi-agent path finding. Artificial Intelligence,
310:103752.
Sharon, G., Stern, R., Felner, A., and Sturtevant, N. R.
(2015). Conflict-based search for optimal multi-agent
pathfinding. Artificial Intelligence, 219:40–66.
Silver, D. (2005). Cooperative pathfinding. In Proceedings
of the aaai conference on artificial intelligence and in-
teractive digital entertainment, volume 1, pages 117–
122.
Smith, R. G. (1980). The contract net protocol: High-
level communication and control in a distributed
problem solver. IEEE Transactions on computers,
29(12):1104–1113.
Yamauchi, T., Miyashita, Y., and Sugawara, T. (2022).
Standby-based deadlock avoidance method for multi-
agent pickup and delivery tasks. In Proceedings of the
21st International Conference on Autonomous Agents
and Multiagent Systems, pages 1427–1435.
Zhang, X., Chen, L., Ai, Y., Tian, B., Cao, D., and Li, L.
(2021). Scheduling of autonomous mining trucks: Al-
location model based tabu search algorithm develop-
ment. In 2021 IEEE International Intelligent Trans-
portation Systems Conference (ITSC), pages 982–989.
Zhang, X., Guo, A., Ai, Y., Tian, B., and Chen, L. (2022).
Real-time scheduling of autonomous mining trucks
via flow allocation-accelerated tabu search. IEEE
Transactions on Intelligent Vehicles, 7(3):466–479.
ICAART 2024 - 16th International Conference on Agents and Artificial Intelligence
332