Increasing Cost Tree Search (ICTS) is an optimal, centralized algorithm for solving the Multi-Agent Path Finding (MAPF) problem. It operates by searching a tree of possible cost combinations for all agents, systematically exploring increasing values for the maximum allowable cost (the makespan) or the sum of individual costs (Sum of Costs). The core innovation is its two-level structure: a high-level search over combined cost budgets and a low-level search that verifies if individual agent paths exist within that budget.
Glossary
Increasing Cost Tree Search (ICTS)

What is Increasing Cost Tree Search (ICTS)?
Increasing Cost Tree Search (ICTS) is an optimal, centralized algorithm for solving the Multi-Agent Path Finding (MAPF) problem.
The algorithm's efficiency stems from aggressive pruning using Multi-Value Decision Diagrams (MDDs). For a given cost budget, an MDD is built for each agent, compactly representing all its optimal paths. The low-level search then finds a set of paths, one from each agent's MDD, that are mutually collision-free. If no conflict-free combination exists for a budget, the high-level search increments the budget and repeats. This structure avoids the exponential growth of searching the full joint state space, making ICTS a foundational optimal MAPF technique.
Core Mechanisms of ICTS
Increasing Cost Tree Search (ICTS) is an optimal Multi-Agent Path Finding (MAPF) algorithm. It operates by searching a tree of possible cost combinations for all agents, systematically pruning branches where an individual agent's cost exceeds the combined budget.
Cost Tree Structure
ICTS does not search the joint state-space of all agents directly. Instead, it searches a Cost Tree where each node represents a vector of possible path costs for each agent. The root node contains the optimal individual path cost for each agent, ignoring others. The algorithm then explores increasing the sum of costs (SOC) budget, generating new cost vectors where one or more agents' costs are incremented. This high-level search identifies feasible cost combinations before verifying them with low-level pathfinding.
Multi-Valued Decision Diagram (MDD)
For each agent and a given cost bound, ICTS builds a Multi-Valued Decision Diagram (MDD). An MDD is a directed acyclic graph that compactly encodes all possible optimal paths for that single agent within the specified cost limit. Nodes represent locations, and edges represent moves across time steps.
- Key Property: An MDD for cost
ccontains all paths of length exactlycfrom start to goal. - Function in ICTS: The MDD allows the algorithm to efficiently check if a set of cost-compatible paths (from the Cost Tree) can be combined into a joint, collision-free plan without searching all possible permutations.
High-Level vs. Low-Level Search
ICTS uses a two-level search hierarchy to decouple cost optimization from collision checking.
- High-Level Search: Explores the Cost Tree. For each candidate cost vector, it passes the individual cost bounds to the low-level search.
- Low-Level Search: For each agent, it generates an MDD based on its assigned cost bound from the high level. It then performs a depth-first search over the Cartesian product of all agents' MDDs to find a non-conflicting combination of paths. If found, a solution exists for that cost vector. If not, the high-level search continues.
Optimality Guarantee
ICTS is an optimal MAPF algorithm for the Sum of Costs (SOC) objective. It guarantees finding the solution with the minimum possible total distance traveled by all agents, provided one exists.
Mechanism of Guarantee:
- The Cost Tree is explored in a best-first order based on the SOC of each cost vector.
- The first cost vector for which the low-level search finds a conflict-free joint plan is, by definition, the optimal SOC. The algorithm systematically proves that no lower-cost combination is feasible.
Pruning via MDD Intersection
A core efficiency mechanism in ICTS is pruning the low-level search by detecting implicit conflicts through MDD analysis. Before a full depth-first search, the algorithm can perform pairwise checks:
- If the MDDs of two agents do not intersect in space-time for their given cost bounds, those agents cannot conflict, and their path combination is trivially valid.
- If MDDs intersect only at specific nodes/edges, the search can be constrained to avoid those conflicts early. This pruning prevents the exponential exploration of all path combinations within the MDDs.
Relation to Conflict-Based Search (CBS)
ICTS and Conflict-Based Search (CBS) are sister algorithms, both providing optimal SOC solutions but with complementary approaches.
Key Contrasts:
- Search Space: ICTS searches in the space of cost combinations. CBS searches in the space of constraints on agent behavior.
- Data Structure: ICTS uses MDDs to encode path sets. CBS uses constraint trees and replans individual paths.
- Performance Profile: ICTS can be more efficient when many agents have similar, short optimal paths. CBS often excels when conflicts are sparse but complex. The choice between them is often problem-dependent.
How Increasing Cost Tree Search Works: A Step-by-Step Breakdown
Increasing Cost Tree Search (ICTS) is an optimal algorithm for Multi-Agent Path Finding (MAPF). It systematically explores combinations of individual path costs to find a set of collision-free paths for all agents.
Increasing Cost Tree Search (ICTS) is an optimal, two-level search algorithm for the Multi-Agent Path Finding (MAPF) problem. At its core, ICTS searches a tree of possible cost combinations for all agents, where the root is the sum of the costs of each agent's shortest individual path. The algorithm incrementally increases this global cost bound and searches for a valid combination of individual paths that sum to this total without collisions.
The search operates by first generating a Multi-Valued Decision Diagram (MDD) for each agent, which compactly encodes all optimal paths for that agent at a given cost. ICTS then performs a depth-first search over the Cartesian product of these MDDs to find a compatible set of paths. A conflict check prunes branches where agents collide, ensuring the final solution is both optimal for the sum of costs and collision-free.
ICTS vs. Other Centralized MAPF Algorithms
A feature and performance comparison of Increasing Cost Tree Search (ICTS) against other prominent optimal and bounded-suboptimal centralized Multi-Agent Path Finding algorithms.
| Feature / Metric | Increasing Cost Tree Search (ICTS) | Conflict-Based Search (CBS) | Multi-Agent A* (MAA*) |
|---|---|---|---|
Algorithmic Paradigm | Cost-bounded tree search over MDDs | Two-level constraint-based search | A* search in joint state space |
Optimality Guarantee | Optimal (for Sum of Costs) | Optimal (for Sum of Costs) | Optimal (for Sum of Costs) |
Primary Search Space | Tree of cost combinations | Constraint tree (high-level) & individual paths (low-level) | Joint state space (exponential in agents) |
Core Data Structure | Multi-Valued Decision Diagram (MDD) | Constraint tree & Conflict Avoidance Table (CAT) | Open list & closed list for joint states |
Conflict Resolution Method | Implicit via cost bound pruning | Explicit via constraint addition & replanning | Explicit via state exclusion in joint space |
Typical Scalability (Agents) | Medium (10-30) | High (10-100+) | Very Low (2-4) |
Memory Complexity | Moderate (MDD storage) | Moderate (constraint tree growth) | Very High (exponential state storage) |
Best Performance On | Problems with tight, uniform cost bounds | Problems with sparse, resolvable conflicts | Theoretically optimal for tiny fleets |
Handles Cardinal Conflicts | |||
Supports Bounded Suboptimality | |||
Solution Time (Typical) | Fast for solvable cost bounds | Varies with conflict density | Prohibitively slow for >4 agents |
Frequently Asked Questions
Increasing Cost Tree Search (ICTS) is an optimal, centralized algorithm for Multi-Agent Path Finding (MAPF). These questions address its core mechanics, applications, and how it compares to other planning methods.
Increasing Cost Tree Search (ICTS) is an optimal, centralized algorithm for solving the Multi-Agent Path Finding (MAPF) problem by searching a tree of possible cost combinations for all agents. It operates in two levels: a high-level search explores a Cost Tree, where each node represents a vector of individual path costs (e.g., (cost_agent_A, cost_agent_B, ...)). The root is the sum of the costs of each agent's shortest path ignoring others. The algorithm then systematically increases the global cost bound and explores new cost combinations. For each cost vector, a low-level search uses Multi-Value Decision Diagrams (MDDs) to verify if collision-free paths exist for all agents that satisfy those exact individual costs. The search prunes branches where any agent's required cost exceeds its MDD's possible minimum, ensuring optimality for the Sum of Costs (SOC) metric.
Enabling Efficiency, Speed & Accuracy
Intelligent Analysis, Decision & Execution
We build AI systems for teams that need search across company data, workflow automation across tools, or AI features inside products and internal software.
Talk to Us
Search across company data
Give teams answers from docs, tickets, runbooks, and product data with sources and permissions.
Useful when people spend too long searching or get different answers from different systems.

Automate internal workflows
Use AI to route work, draft outputs, trigger actions, and keep approvals and logs in place.
Useful when repetitive work moves across multiple tools and teams.

Add AI to products and internal tools
Build assistants, guided actions, or decision support into the software your team or customers already use.
Useful when AI needs to be part of the product, not a separate tool.
Related Terms
Increasing Cost Tree Search (ICTS) operates within a rich ecosystem of algorithms and concepts for coordinating multiple agents. These related terms define the core problems, alternative solutions, and performance metrics in the MAPF domain.
Multi-Agent Path Finding (MAPF)
Multi-Agent Path Finding (MAPF) is the foundational computational problem that ICTS solves. It involves finding collision-free paths for multiple agents from their start locations to their goal locations in a shared, typically discretized, environment. The core challenge is the combinatorial explosion of possible joint actions.
- Optimality Criteria: Solutions are evaluated on metrics like Sum of Costs (SOC) or Makespan.
- Centralized vs. Decoupled: Algorithms like ICTS and CBS are centralized, while methods like Priority Planning are decoupled.
- Core Constraints: Solutions must avoid Vertex Conflicts and Edge Conflicts.
Conflict-Based Search (CBS)
Conflict-Based Search (CBS) is the primary alternative optimal algorithm to ICTS for solving MAPF. It employs a two-level search: a high-level constraint tree and low-level path planners for individual agents.
- Constraint Resolution: When a conflict (e.g., two agents occupying the same vertex at the same time) is detected, CBS branches by adding constraints that prevent the conflict, forcing one agent to avoid that space-time cell.
- Comparison to ICTS: While ICTS searches a tree of cost combinations, CBS searches a tree of constraints. CBS often has superior performance in practice due to more effective pruning.
- Bypass Conflict: A refinement where an agent's path is locally adjusted to go around another without increasing cost, avoiding a new constraint branch.
Multi-Value Decision Diagram (MDD)
A Multi-Value Decision Diagram (MDD) is a compact, directed acyclic graph that encodes all possible optimal paths for a single agent from start to goal within a specific cost bound (e.g., length or time).
- Core ICTS Component: ICTS uses MDDs to represent the search space for each agent efficiently. The algorithm searches over combinations of MDD levels.
- Pruning Power: By intersecting MDDs, ICTS can quickly prune combinations of paths where agents would collide, as no compatible state exists at that time step.
- Structure: An MDD for cost C has C+1 layers, where each node represents a world state the agent can be in at that time step while staying optimal.
Sum of Costs (SOC) & Makespan
These are the two primary optimality criteria for evaluating MAPF solutions, which ICTS is designed to optimize.
- Sum of Costs (SOC): Also called Flowtime. Defined as the sum of the path lengths (or travel times) for all individual agents. ICTS directly minimizes SOC by searching cost combinations. Example: Three agents with path lengths 5, 7, and 9 have an SOC of 21.
- Makespan: The total time elapsed from the start until the last agent reaches its goal. This metric focuses on overall completion time rather than total effort. Algorithms can be tailored to optimize for one metric or the other.
Cardinal Conflict
A Cardinal Conflict is the most severe type of conflict in MAPF. It occurs between two agents where any feasible resolution (e.g., making one agent wait) unavoidably increases the sum of their path costs.
- Impact on Search: Identifying cardinal conflicts is crucial for efficient search. In algorithms like CBS, recognizing a conflict as cardinal allows the search to prune one of the two resulting branches immediately, as it cannot lead to a better solution.
- Relation to ICTS: In the ICTS framework, a cardinal conflict would manifest as a situation where, for a given cost budget, the MDDs of the two agents have no non-conflicting path combination, forcing the search to a higher cost tier.
Bounded Suboptimal Search
Bounded Suboptimal Search refers to a class of algorithms that sacrifice guaranteed optimality for dramatic gains in speed, with a provable bound on solution quality (e.g., no more than 1.2x the optimal cost).
- Scalability Trade-off: Optimal algorithms like ICTS and CBS can be slow for large fleets. Bounded suboptimal variants (e.g., Enhanced CBS (ECBS)) use focal searches and cost heuristics to find good solutions quickly.
- Engineering Relevance: In many real-world logistics and warehousing applications, a provably good enough solution computed in milliseconds is more valuable than an optimal solution computed in minutes.

About the author
Prasad Kumkar
CEO & MD, Inference Systems
Prasad Kumkar is the CEO & MD of Inference Systems and writes about AI systems architecture, LLM infrastructure, model serving, evaluation, and production deployment. Over 5+ years, he has worked across computer vision models, L5 autonomous vehicle systems, and LLM research, with a focus on taking complex AI ideas into real-world engineering systems.
His work and writing cover AI systems, large language models, AI agents, multimodal systems, autonomous systems, inference optimization, RAG, evaluation, and production AI engineering.
Partnered with leading AI, data, and software stack.
How We Work
Custom AI workflows for your Business
One-fit-all AI don't work for modern businesses. At Inferensys, we aim to understand your business & custom requirements; which we use to define most efficient agentic workflows, the data, and the tools for your business.
01
Review the use case
We understand the task, the users, and where AI can actually help.
Read more02
Pick the right approach
We define what needs search, automation, or product integration.
Read more03
Build the first useful version
We implement the part that proves the value first.
Read more04
Improve from there
We add the checks and visibility needed to keep it useful.
Read moreThe first call is a practical review of your use case and the right next step.
Talk to Us