[Paper Review] Comparison between Behavior Trees and Finite State Machines

Matteo Iovino, Julian Förster+4 more|arXiv (Cornell University)|May 25, 2024

Evolutionary Algorithms and Applications4 citations

TL;DR

This paper compares Behavior Trees (BTs) and Finite State Machines (FSMs) for robot control in mobile manipulation tasks, using shared low-level skills to ensure fairness. It finds that while both yield equivalent behavioral outcomes, BTs significantly reduce programming effort and improve maintainability in complex tasks due to superior modularity, reactivity, and readability, especially as task complexity increases.

ABSTRACT

Behavior Trees (BTs) were first conceived in the computer games industry as a tool to model agent behavior, but they received interest also in the robotics community as an alternative policy design to Finite State Machines (FSMs). The advantages of BTs over FSMs had been highlighted in many works, but there is no thorough practical comparison of the two designs. Such a comparison is particularly relevant in the robotic industry, where FSMs have been the state-of-the-art policy representation for robot control for many years. In this work we shed light on this matter by comparing how BTs and FSMs behave when controlling a robot in a mobile manipulation task. The comparison is made in terms of reactivity, modularity, readability, and design. We propose metrics for each of these properties, being aware that while some are tangible and objective, others are more subjective and implementation dependent. The practical comparison is performed in a simulation environment with validation on a real robot. We find that although the robot's behavior during task solving is independent on the policy representation, maintaining a BT rather than an FSM becomes easier as the task increases in complexity.

Motivation & Objective

• To provide a practical, fair comparison between Behavior Trees (BTs) and Finite State Machines (FSMs) in robot policy design for mobile manipulation tasks.
• To evaluate and quantify differences in reactivity, modularity, readability, and design effort between BTs and FSMs using concrete robotic examples.
• To validate that BTs reduce programming effort and improve maintainability compared to FSMs, especially in complex, hierarchical tasks.
• To extend prior work by including hierarchical FSMs, real-robot validation, and new metrics for algorithmic complexity and graph structure.
• To demonstrate that BTs offer inherent advantages in fault tolerance and hierarchical task structuring, even when FSMs are redesigned to mimic BT behavior.

Proposed method

• The authors implemented identical low-level robot skills (e.g., navigation, object pickup, docking) for both BT and FSM controllers, ensuring a fair comparison.
• They used a depth-first pre-order traversal mechanism to tick BTs, with control nodes (Sequence, Fallback, Parallel) and execution nodes (Action, Condition) defining behavior.
• For FSMs, they designed a fault-tolerant variant where all states connect to a central 'selector' state to enable reactivity, mimicking BT behavior.
• Metrics were introduced to quantify modularity (via shared input/output structure), reactivity (via transition complexity and fault recovery effort), and readability (via graph distance and structural complexity).
• The comparison was evaluated in simulation using the RoboCup@Home benchmark tasks, with validation on a real mobile manipulator at the WASP Research Arena.
• Algorithmic complexity bounds and graph distance measures were used to objectively compare structural differences between BT and FSM representations.

Experimental results

Research questions

• RQ1 How do BTs and FSMs compare in terms of reactivity when handling unexpected events like low battery or failed actions?
• RQ2 To what extent does modularity differ between BTs and FSMs, and how does this affect maintainability and reusability in complex tasks?
• RQ3 How does readability of the policy representation change with increasing task complexity in BTs versus FSMs?
• RQ4 What is the relative programming effort required to implement and modify a policy using BTs versus FSMs in real-world mobile manipulation tasks?
• RQ5 Can a redesigned FSM achieve similar reactivity to a BT, and if so, what is the cost in terms of structural complexity and implementation effort?

Key findings

• The robot’s behavior during task execution was functionally identical whether controlled by a BT or an FSM, confirming that behavioral outcomes are independent of policy representation.
• BTs demonstrated superior modularity: entire subtrees can be reused, tested, and verified independently, whereas FSM states require modification of all associated transitions.
• Reactivity was inherently supported in BTs via the 'Running' status and hierarchical control nodes, while FSMs required explicit redesign (e.g., universal transitions to a selector state) to achieve similar fault tolerance.
• Readability in FSMs degrades with increasing complexity due to high transition density, whereas BTs maintain clarity through hierarchical tree structure, even in complex tasks.
• Programming effort increased significantly with task complexity in FSMs, especially when handling priority-based task switching and failure recovery, while BTs scaled more gracefully.
• The use of graph distance and algorithmic complexity metrics confirmed that BTs have a more compact and structured representation than FSMs, especially in hierarchical tasks.