Proceedings of the Twenty-First International FLAIRS Conference (2008)
Recovering from Inconsistency in Distributed Simple Temporal Networks
Anthony Gallagher and Stephen F. Smith
The Robotics Institute
Carnegie Mellon University
Pittsburgh PA 15213
{anthonyg,sfs}@cs.cmu.edu
hedge against execution dynamics: Many deviations from
scheduling-time assumptions are absorbed by simply sliding
the sequence of activities within their feasible time window
without need for rescheduling. Deviations from schedulingtime assumptions that cannot be absorbed by the flexibility
in the feasible time windows of activities indicate the presence of conflicting temporal constraints, and signal a need
for updating the schedule. While a centralized scheduler has
full control over all scheduling decisions, agents in a distributed scenario typically do not enjoy such freedom. The
agent may need to revise its schedule while contending with
incomplete knowledge of the global situation, and the inability to change the scheduling decisions of other agents.
Previous research on dealing with uncertainty in an STN
context has mostly focused on preventative measures: Designing schedules that take into account all possible deviations from schedule-time assumptions and make provisions
that avoid temporal conflicts arising during execution. Controllability theory was developed to reason about uncertainty
in activity durations within an STN context (Vidal & Fargier
1997). The goal is to create schedules that can execute without encountering temporal conflicts. To ensure this property, an explicit model of uncertainty needs to exist during scheduling-time prior to execution. However, uncertainty can be hard to completely quantify. Another potential drawback of constructing such “fail-safe” schedules is
that these schedules make conservative assumptions to safeguard against worst-case events. A less conservative approach could potentially yield higher benefits.
Temporal decoupling provides another solution to enable
STN scheduling agents to execute their schedules without
mutual interference (Hunsberger 2002). A global STN is
initially partitioned, so that each agent receives a “decoupled” STN that introduces new constraints preventing the
agent’s scheduled activities from affecting the activities of
other agents. Similar to controllability, the decoupling of
the STN implies prior knowledge of the upper bounds on
activity durations. The decoupling process pre-partitions the
slack of the activities, reducing inter-agent flexibility in the
name of execution-time non-interference between the schedules.
Another multi-agent scheduling approach using an STN
infrastructure is described in (Brambilla & Lavagna 2006).
Here, agents coordinate to create a schedule that is guaran-
Abstract
Simple Temporal Networks (STNs) are frequently used in
scheduling applications, as they provide a powerful and general tool for managing temporal constraints. One obstacle to
their use in multi-agent scheduling contexts, however, is the
additional problem of maintaining consistency across agent
models. Like in centralized applications, unexpected execution results (e.g., an activity taking longer to execute than
planned) can introduce conflicts into an agent’s local model
that require changes to its current local schedule. But in a distributed environment these local changes must also be propagated to those other agents with interdependent decisions,
and the asynchrony and latency of this communication can
introduce inter-agent inconsistency. In this paper, we consider the problem of managing and recovering from detected
inconsistencies in a distributed STN-based scheduling framework. Our approach exploits a higher, domain-level semantics of the temporal constraints posted in the STN to design a
set of strategies to update the agent’s schedule and resolve the
STN conflict. We present experimental results on a suite of
problems involving coordinated management of joint schedules that indicate the potential of our approach.
Introduction
This paper examines the use of Simple Temporal Networks
(STNs) (Dechter, Meiri, & Pearl 1991) in distributed/multiagent scheduling applications with dynamic, uncertain environments. Temporal network-based approaches, and STNs
in particular, have found increasing application in a variety
of scheduling domains. STNs encode activities and the temporal constraints linking them as nodes and edges in a graph.
Through standard graph algorithms, STNs provide powerful
tools to evaluate the effect of temporal constraints on the feasible start and finish times of activities, and detect situations
where two or more temporal constraints are in conflict with
one another.
STN-based schedulers produce flexible-times schedules
that provide scheduled activities with feasible time windows over which they can be executed, unlike traditional
fixed-times scheduling approaches that peg scheduled activities to specific start and finish times. In dynamic environments, these flexible-times schedules bestow an inherent
c 2008, Association for the Advancement of Artificial
Copyright Intelligence (www.aaai.org). All rights reserved.
549
The Problem Domain
teed to avoid conflicts over a limited future horizon, and then
periodically extend schedules according to a rolling horizon.
Alternatively, other researchers have focused on distributing
a global STN over several agents (Buzing, ter Mors, & Witteveen 2004; Wehowsky, Block, & Williams 2005). Each
agent owns a subset of the nodes in the STN (corresponding to the activities they are responsible for), and the effects of constraints are propagated across agents whenever
their nodes are involved. This approach, while distributed,
does not enable agents to act independently. Rather, a single
STN propagation occurs at any one time, so agents need to
synchronize their reasoning. Even hypothetical deliberation
involving only local activities may involve communication
with other agents.
In this paper, we consider the problem of managing and
recovering from inconsistency in an agent’s model during
schedule execution, while ensuring the consistency of local
activities. Our aim is to exploit the flexibility provided by
STN schedules in a multi-agent context, where agents must
make asynchronous decisions in response to execution dynamics, there is no ability to predict all possible world outcomes, and schedules must be repaired when conflicts arise
so that execution can continue. We propose a set of schedule
revision strategies that apply domain-level semantics to analyze the temporal conflicts that arise during execution, and
take appropriate conflict resolution actions. These strategies
range from local changes to the agent’s schedule, to more
complex actions that suspend the use of information involving remote activities until new information arrives. We compare the performance of our approach to that of (1) a baseline approach that simply ignores information that produces
temporal conflicts, and (2) a conservative approach that uses
fail-safe schedules to avoid execution-time inconsistencies.
Our focus is on multi-agent scheduling problems that require
a team of agents to collaboratively execute a network of activities in a dynamic, uncertain environment. We assume
that the network of activities is generated and distributed to
the team of agents prior to execution, but that no agent has
complete visibility of this joint plan and its underlying constraints. Instead each agent is initialized with its own subjective view of the problem and the plan, which consists of
the portion of the activity network that the agent is responsible for executing (referred to as local activities) together
with those activities owned by other agents (referred to as
remote activities) that share structural or causal dependencies with the agent’s local activities. An agent’s subjective
view also includes a set of local contingencies that provide
fall-back options if activities in the initial plan/schedule become infeasible or undesirable as execution unfolds. The
team of agents coordinate their actions and jointly revise
their schedules as execution events force changes. As activities are successfully executed, the team of agents accrues
quality and the objective is to maximize total payoff.
The problem and the initial schedule is specified in
C TAEMS, a dialect of the TAEMS modeling language created by the DARPA Coordinators project(Decker & Lesser
1993). In C TAEMS, a plan is represented as a tree structure, similar to an ”unrolled” hierarchical task network
(HTN) planning model. Leaf activities, called methods,
correspond to executable activities, and each method designates a particular agent as being responsible. Each method
also has an expected duration and quality, both expressed as
probability distributions. If a method fails to execute successfully, it accrues no quality. Higher-level activities are
called tasks, and aggregate lower-level tasks or methods.
Each task has an associated quality accumulation function
(QAF) that determines how the task accrues quality from its
children activities. General QAFs are provided that sum,
maximize or minimize the quality of the task’s children.
More specialized QAFs also define synchronization points
(where quality is accumulated only if all children start at the
same time), and mutual exclusivity (where only one child
can be executed). The ultimate quality accrued by executing
a C TAEMS plan is that accrued at the root of the task tree.
Any method or task in the hierarchy can have an associated release time and/or deadline. Methods inherit any such
time constraints associated with ancestor tasks, and methods
that start or finish outside of their feasible window accrue
no quality. Non-local effects (NLEs) model causal interdependencies between a source activity and a target activity.
Hard NLEs define a relation that must be enforced for the
target activity to accrue quality, while soft NLEs define preferences that affect the amount of quality accrued. From a
temporal perspective, an NLE becomes satisfied (or active)
at the moment that the source activity accrues positive quality. Thus, in the case where the source activity of an NLE is
a task, the target activity can often start before all children
have executed.
Figure 1 shows a simple C TAEMS plan for two agents.
Agent White owns the “white” activities in the left subtree,
while Agent Black owns the “black” activities in the right
Simple Temporal Networks Background
An STN is a graph G < N, E >. A node in N represents a
time point. Each edge in E represents a distance constraint
between two time points in N . A distance constraint between Xi ∈ N and Xj ∈ N is of the form:
l ≤ (Xj − Xi ) ≤ u
(1)
where l and u are the lower and upper bounds on the distance
between the time points. A special time point, called timezero grounds the network and has a fixed value of 0. Unary
constraints that act on a single time point can be casted into
a distance constraint of the form used in equation 1 by using
the time-zero point. For example, the constraint Xk ≥ C is
equivalent to the distance constraint C ≤ (Xk − time-zero)
≤ ∞. The STN maintains the lower and upper bounds of all
time points in N by propagating the effects of the distance
constraints. All temporal constraints on activities (such as
release dates, deadlines, durations, causal constraints, etc)
can be abstracted using this formulation as simple distance
constraints between time points. The addition of a distance
constraint or a change to an existing constraint can give rise
to conflicts. The STN detects these conflicts by checking for
negative cycles in the graph G. The presence of a negative
cycle denotes a conflict.
550
Agent White’s View
Joint Plan
MIN
Agent White
X
MAX
Joint Plan
Agent Black
Y
MAX
MIN
Rel: 25
Dd: 40
X
Rel: 5
Dd: 30
A
B
Q: 5
D: 5
Q: 20
D: 20
causal
NLE
Rel: 5
Dd: 30
D
C
Q: 15
D: 10
MAX
A
Q: 8
D: 10
B
C
causal
NLE
time-zero
Figure 1: The Joint Plan
<25, 䌩>
X
[5, 7]
MAX
<-䌩, 40>
<-䌩, 30>
<5, 䌩>
Joint Plan
MIN
<23, 23>
[28, 27]
<0, 䌩>
[27, 28]
<13, 13> [27, 40]
Rel: 5
Dd: 30
A
B
Figure 3: An unexpectedly long duration causing a conflict.
C
causal
NLE
unscheduled
ing agents can produce flexible-times schedules capable of
absorbing many of these deviations, flexibility is ultimately
a function of the problem constraints and schedule load of
the agent, and some deviations can introduce an inconsistency that cannot be absorbed by the STN. Figure 3 displays
the inconsistency introduced when method B finishes late.
The conflict manifests as inconsistent bounds for the finish
point of B and the start point of C. To restore consistency,
it is necessary to make changes to the schedule, so that the
conflict is removed (e.g. such as unscheduling C in this scenario). At the STN level, a conflict indicates that a subset of constraints are mutually inconsistent, and results in a
negative cycle. The cycle involves a subset of the edges in
the graph, which can be retrieved using standard graph algorithms. To resolve the conflict one or more edges in the
cycle must be retracted or modified.
Our approach to conflict resolution builds upon previous
research in STN temporal conflict explanations (Smith et al.
2005; Bresina & Morris 2006). These techniques map the
edges and nodes involved in an STN conflict to specific constraints and activities in the domain model. Once the constraints and activities in the conflict have been identified, the
types of the constraints in the conflict (i.e. release/deadline
constraints, duration constraints, etc) are used to explain the
situation that causes the conflict. For the example in Figure
3, the negative cycle in the STN includes the constraints representing the release constraint of B, the duration of B, the
causal NLE between B and C, the duration of C, and the
deadline of C. Superimposing our activity model onto these
constraints, we find that local method B and remote method
C are the activities involved in the conflict.
In the following subsections, we propose a set of strategies for modifying an agent’s local state when a temporal
conflict is detected in its STN. The main goal of our conflict resolution strategies is to restore local consistency of
the STN while ensuring that the scheduled local activities
satisfy all known constraints that apply to them. In some
cases, simple local actions are sufficient to accomplish this
time-zero
<-䌩, 40>
<-䌩, 30>
<25, 䌩>
<5, 䌩>
<20, 20>
[5, 7]
est(B) lst(B)
<0, 䌩>
[25, 27] [25, 27]
eft(B) lft(B)
<13, 13>
[38, 40]
Figure 2: The View of Agent White and its STN Mapping
subtree. The top of Figure 2 shows the subjective view of
Agent White. Agent White sees its local activities X, A
and B, plus remote activity C (since an NLE links methods
B and C). For simplicity, methods are annotated with their
expected quality (Q), and their expected duration (D) instead
of corresponding probability distributions.
Each task and method in the C TAEMS hierarchy is represented naturally in the STN by two time points (representing the start and finish of the activity). Various constraints
(i.e., method durations, parent/child relations, NLEs, release
times, deadlines) are encoded as links between appropriate
pairs of points in this set and the special time-zero point. The
bottom of Figure 2 shows the activity model of Agent White
mapped to time points and links in the STN. The STN representation shows the time points corresponding to methods
B and C, and the constraints acting on these activities. As
mentioned earlier, the STN maintains bounds on the feasible
execution windows methods and tasks. The current earliest start time (est(.)), latest start time (lst(.)), earliest finish
time (ef t(.)) and latest finish time (lst(.)) for methods B
and C are displayed at the bottom of Figure 2.
Schedule Revision Strategies to Resolve STN
Conflicts
During schedule execution in a dynamic environment, unforeseen events can frequently deviate from assumptions
made during scheduling-time. While STN-based schedul-
551
ods from the agent’s timeline. These conflicts are characterized by the presence of one or more retractable constraints in the Conflict Set, and are of two types: (1)
Conflicts involving an NLE that targets a local pending
method, and (2) conflicts where a local pending method is
in conflict with its release/deadline. The first type of conflict indicates that the NLE targeting the local method can
no longer be enforced. Removing this method from the
schedule resolves the conflict 1 . The second type of conflict indicates that a local pending method is not able to
meet its release and/or deadline constraints. Typically this
happens when the feasible time window of the method is
compressed during schedule execution. The conflict can
be removed by unscheduling the activity.
The types of conflict that can be resolved through making
local changes to the schedule are akin to those that occur
in a centralized scheduling application, where the scheduler can make self-contained decisions regarding modifications to the schedule to resolve a temporal conflict.
When no local changes to the schedule can restore feasibility, an additional set of strategies is needed to resolve
the inconsistency while ensuring that the scheduled activities of the agent respect all model constraints.
• Suspending an NLE: These types of conflicts are characterized by the presence of an NLE targeting a remote activity in the Conflict Set. The local agent is unable to unschedule this activity to resolve the conflict, so it chooses
the next best option: It suspends the enforcement of the
NLE by temporarily retracting it from the STN, keeping
it aside for future reinsertion when updated information
on the remote target activity is received that resolves the
conflict (e.g. when the agent hears that the start time of the
remote target activity has been moved forward in time).
Suspending an NLE can have extended repercussions on
the feasibility of the local schedule. If the remote target
activity of the NLE is a task, then all descendant activities “inherit” this NLE, and its suspension affects their
bounds. To ensure that local descendant activities respect the suspended NLE, new helper NLEs are created
between the source activity and all local methods that are
descendants of the remote target task. Any local methods
that are inconsistent with enforcing the NLE are unscheduled. Figure 4 shows an example of this situation. Agent
Black owns a scheduled method N under remote task M .
An NLE links remote method B to M . When B’s finish time is moved forward, the NLE can no longer be enforced. Since both B and M are remote, Agent Black
cannot arbitrarily modify their information. Instead, the
NLE between B and M is suspended. Nonetheless, Agent
Black needs to ensure that its local scheduled methods are
consistent with the NLE: Agent Black’s method N inherits the NLE from its parent task M , and must come after
B. A new helper NLE is inserted directly between B and
N . This helper NLE ensures that N respects the original NLE, safeguarding the feasibility of Agent Black’s
goal. In others, it is necessary to make assumptions about
the continuing validity of information previously reported
about remote activities by other agents.
Categorizing Constraints in the Conflict Set
As indicated above, the first step in analyzing an inconsistency that has been introduced into the STN is to map the set
of edges involved in the detected negative cycle to the corresponding set of domain level constraints. We refer to this
latter set as the Conflict Set. The constraints in any given
Conflict Set can be partitioned into three non-overlapping
subsets:
• Retractable: These constraints represent local scheduling decisions tied to events in the future (i.e. sequencing
constraints that order the pending methods on the agent’s
timeline). The scheduler is free to retract or modify these
constraints as necessary to resolve a conflict. Retracting sequencing constraints results in the unscheduling of
methods from the agent’s schedule.
• Suspendable: These constraints include the model constraints (i.e. release/deadline constraints or structural
links establishing the hierarchy of activities) tied to future events, and constraints enforcing reported information about pending remote activities. These constraints
cannot be arbitrarily retracted, but their enforcement can
be suspended when no retractable constraint can be removed or modified. For the example in Figure 3, when
B finishes late, the causal NLE between B and pending
remote method C cannot be enforced. The suspendable
constraints are the NLE, the duration of C and the deadline of C.
• Immutable: These constraints represent past events. The
agent needs to resolve the conflict leaving these constraints untouched. For the example in Figure 3, the duration of executed method B is immutable.
The two sets of modifiable constraints (retractable and suspendable) encompass all constraints tied to future events. A
temporal conflict necessarily contains at least one of these
constraints, making it possible to design schedule revision
strategies that guarantee resolution of any conflict that arises
during execution by retracting or suspending some of the
modifiable constraints in the Conflict Set.
Schedule Revision Strategies
Our approach to conflict resolution exploits the above categorization of constraints to define a sequence of repair strategies, each making increasingly stronger assumptions: We
progress from the simple strategy of making local changes
to the agent’s own schedule when this action can resolve the
inconsistency, to more complex changes where a problem
constraint or a constraint reflecting remote activity information needs to be suspended.
More precisely, the following four schedule revision
strategies are applied in succession to resolve any given conflict:
1
Of course, the scheduler may later attempt to reschedule the
method so that the NLE is respected; our concern here is restoring
a consistent state so that the agent scheduler can move forward.
• Unscheduling of local activities: Certain conflicts can be
resolved by the simple unscheduling of one or more meth-
552
Agent Black’s View
schedule. The helper NLE can be removed when updated
information enables the original NLE to be reactivated.
• Suspending the reported duration of a remote activity
when enough local information exists to overwrite it:
When no suspendable NLE is found in the Conflict Set,
yet the Conflict Set includes the duration of a remote activity, it can be inferred that the reported duration for this
remote activity is in conflict with the time window of an
ancestor task. Since the activity is remote, the agent cannot unschedule it to restore feasibility. However, since the
duration of the activity is infeasible, the agent can deduce
that its reported duration is no longer valid. The agent
thus “suspends” the duration of the activity by reducing
it to fit within the time window of its ancestor task, while
waiting for updated information from its owner.
• Suspending a release or deadline constraint: If this case
is reached, the Conflict Set contains neither an NLE nor
a remote activity duration to suspend. Hence, the conflict involves a local activity and the release time/deadline
constraints associated with it or an ancestor task. Further, since the activity cannot be unscheduled (first strategy above), it must be an executed activity and its duration
is thus immutable. The executed activity has violated either its release or deadline constraint. Violating a release
constraint can be trivially avoided prior to execution by
not starting a method before its release. We adopt this
strategy in our agent. Hence, a conflict of this type can always be interpreted as a deadline violation (e.g. a method
finishes late past its deadline and accrues no quality). The
agent’s only choice to restore consistency in the STN is to
suspend the deadline constraint 2 .
After applying the above conflict resolution strategies, the
initial temporal conflict that triggered the process is guaranteed to be resolved. In some cases, however, the resolution
of a given conflict will unmask other, less severe temporal
conflicts. The above described schedule revision procedure
is thus repeatedly applied until the STN is conflict-free.
Joint Plan
MIN
M
causal
NLE
B
MAX
N
helper
NLE
time-zero
<-䌩, 40>
<8, 8>
<25, 䌩>
<0, 䌩>
<-䌩, 28>
<5, 䌩>
[5, 7]
<23, 23>
[28, 27]
<0, 䌩>
[27, 28]
<13, 13>
[27, 40]
Figure 4: Suspending a causal NLE to a remote target.
• Modifications to existing activities including changes to
the release/deadline, or utility/duration expected.
We compared four strategies to deal with the inconsistencies
that arise during schedule execution. The first two implement inconsistency management approaches based on previous work, while the last two use the conflict resolution
strategies developed in this paper:
• Baseline (BL): This strategy consists of an agent that resolves execution related conflicts (e.g. a late-finish of an
activity), but ignores non-execution related inconsistencies (e.g. an update on a remote pending activity from another agent). The integrity of the local schedule is maintained by an execution-time policy that waits until causal
NLEs are satisfied before starting the execution of local
pending methods. The behavior of this baseline agent
corresponds to the strategy proposed in multi-agent Truth
Maintenance Systems (TMSs) where agents “agree to disagree”, and information sent by remote agents can be ignored if inconsistent (Huhns & Bridgeland 1991).
Experimental Design and Results
To test the validity of our approach, we conducted experiments using the real-time, multi-agent simulation environment provided by the DARPA Coordinators program. This
simulator manages both asynchronous communication between agents and the passage of time, informing the agents
the current time in discrete intervals, called ticks. Three
forms of execution-time dynamics are inserted during a
given run:
• Uncertainty in utility/duration obtained, with activities accruing more/less utility than expected or taking more/less
time than expected.
• New sets of activities added to the plan during execution.
• Conservative (MD): This strategy uses a conservative
scheduling approach, where agents schedule methods assuming they will execute their maximum duration. This
strategy is akin to the preventative approaches used in previous STN-based multi-agent applications that construct
fail-safe schedules that avoid inconsistencies during execution (Vidal & Fargier 1997; Hunsberger 2002).
• Aggressive Conflict Resolution (ACR): In this strategy,
the agent resolves inconsistencies immediately when they
arise using the strategies described in the previous section.
• Delayed Conflict Resolution (DCR): Given the asynchronicity in agent communication, messages can arrive
out of order and produce transient inconsistent states that
get sorted out if the agent were to wait for the missing information pieces. The delayed conflict resolution strategy
adopts a wait-and-see philosophy and temporarily ignores
information that leads to non-execution related conflicts.
2
If the violated deadline is “inherited” from an ancestor task, it
is sufficient to break the structural constraints linking the method
to its parent task. Decoupling the late method from its parent minimizes the impact of the constraint suspension. Suspending the
deadline constraint itself would instead affect all activities in the
hierarchy below the deadline-holding ancestor task.
553
straint in the problem, pending arrival of new information
that resolves the conflict. The constraints that can be suspended fall into three categories: (1) temporal dependencies
with remote activities, (2) duration constraints on remote activities, and (3) problem constraints such as deadlines. When
a constraint is suspended, the agent will ensure that its local
activities respect all constraints acting on them, so that its
schedule remains feasible.
We evaluated two variants of our approach against two
alternative approaches to managing inconsistency on a set
of reference multi-agent scheduling problems. A delayed
conflict resolution strategy, where an agent waits for a small
time period for updated information before resolving inconsistencies was found to outperform all other approaches.
Specifically, the agent waits for 1 tick to receive new information that allows the ignored information to be consistently assimilated, and only after this delay comes up
negative are the repair strategies applied.
Experiments were performed using a set of 81 problems
taken from the Coordinators Phase 2 evaluation test suite:
31 25-agent problems, and 50 50-agent problems. All problems specify an initial schedule computed using a centralized solver. While this solution provides initial guidance to
the agents, dynamics force the agents to make changes to
this solution or recompute a new solution during execution.
Probability distributions for method outcomes contain moderate uncertainty: The maximum value in the distribution
never exceeds the expected value by more than 50%.
The results obtained using the four strategies are shown
in Table 1. For each problem in our set, we computed the
ratio Qs /Qmax obtained by each strategy, where Qs is the
quality value achieved by strategy s, and Qmax is the maximum quality achieved for this problem. As can be seen, BL
is the lowest performer and clearly suffers from the lack of
consistency between the agents’ schedules. Simply ignoring
messages from remote task owners when an inconsistency
occurs results in mutually inconsistent schedules that fail to
respect activity interdependencies. Both MD and ACR are
seen to produce similar results, both significantly improving
over BL. In the case of MD, the robustness of assuming maximum durations is counterbalanced by a tendency execute
fewer methods. Alternatively, ACR sometimes suffers from
excessive reactivity, unnecessarily modifying agent schedules to overcome transient inconsistencies. DCR provides a
better trade-off along both of these dimensions and is seen
to produce the best performance.
Acknowledgments This work was supported in part by
the Department of Defense Advance Research Projects
Agency (DARPA) under Contract #FA8750-05-C-0033 and
by the CMU Robotics Institute.
References
Brambilla, A., and Lavagna, M. 2006. Multi agent conflict partition scheduling for coordinated space systems. In
Proceedings of the IWPSS.
Bresina, J. L., and Morris, P. H. 2006. Explanations and
recommendations for temporal inconsistencies. In Proceedings of the IWPSS.
Buzing, P.; ter Mors, A.; and Witteveen, C. 2004. Multiagent plan repair with dtps. In Brown, K. N., ed., Proceedings of the PlanSIG, 3–14.
Dechter, R.; Meiri, I.; and Pearl, J. 1991. Temporal constraint networks. Artificial Intelligence 49:61–95.
Decker, K., and Lesser, V. R. 1993. Quantitative Modeling
of Complex Environments. International Journal of Intelligent Systems in Accounting, Finance and Management
2:215–234.
Huhns, M., and Bridgeland, D. 1991. Multiagent truth
maintenance. IEEE Transactions on Systems, Man and Cybernetics 21(6).
Hunsberger, L. 2002. Algorithms for a temporal decoupling problem in multi-agent planning. In Proceedings of
AAAI-02.
Smith, S.; Cotellessa, G.; Hildum, D.; and Ohler, C.
2005. Using a scheduling domain theory to compute useroriented explanations. In Castillo, Borrajo, S., and Oddi.,
eds., Planning, Scheduling and Constraint Satisfaction:
From Theory to Practice. Frontiers in Artificial Intelligence
and Applications, volume 117. IOS Press.
Vidal, T., and Fargier, H. 1997. Contingent durations in
temporal csps: From consistency to controllabilities. In
TIME, 78–85.
Wehowsky, A.; Block, S.; and Williams, B. 2005. Robust
distributed coordination of heterogeneous robots through
temporal plan networks. In ICAPS-05 Workshop on Multiagent Planning and Scheduling, 67–72.
Summary
STNs present a powerful framework for reasoning about
temporal constraints, and have found increasing acceptance
in scheduling domains. However, their use in multi-agent
domains is complicated by the need to manage inconsistency in individual agent models. While local consistency
can sometimes be restored by taking local scheduling actions, other conflicts involve remote activities that the agent
cannot arbitrarily modify.
In this paper, we described an approach to resolving STN
conflicts in a multi-agent scheduling setting, allowing individual agents to continue reasoning in the face of potentially
outdated information from other agents. Our strategy starts
by attempting purely local changes, akin to techniques used
in centralized domains. However, if no local action can resolve the conflict, the agent attempts to suspend some con-
25-agent
50-agent
Overall
BL
0.696
0.797
0.758
MD
0.829
0.880
0.860
ACR
0.829
0.861
0.849
DCR
0.917
0.915
0.915
Table 1: Quality Ratio for Inconsistency Management Approaches
554