Analysis and Exploitation of Synchronized Parallel Executions in Behavior Trees

Lorenzo Natale; Michele Colledanchise

REVIEW 5 major objections 4 minor 23 references

Analysis and Exploitation of Synchronized Parallel Executions in Behavior Trees

T0 review · 5 major / 4 minor · reviewed 2026-08-14 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read This paper defines two synchronized parallel nodes for Behavior Trees—an absolute node with predefined progress barriers and a relative node with a threshold—and shows they reduce progress drift and improve execution predictability.

desk verdict A solid, incremental BT-synchronization paper whose core ideas are usable, but it needs a cleaner formal definition, a fixed pseudocode bug, and weaker statistical claims. read the letter →

arxiv 1908.01539 v1 pith:KFILBDTU submitted 2019-08-05 cs.RO

Michele Colledanchise , Lorenzo Natale This is my paper · ORCID

classification cs.RO

keywords BehaviorTreesparallelcompositionconcurrencysynchronizationbarriersprogressfunctionpredictabilityrobotcontroldistance

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Behavior Trees compose robot behaviors by ticking sub-behaviors in a hierarchy, and parallel composition is attractive but rarely used because concurrent actions can race, drift, or conflict. This paper tries to make parallel composition usable by adding two synchronization control-flow nodes: an absolute node that holds all children at pre-set progress barriers until every child reaches that barrier, and a relative node that stops any child more than a threshold $\Delta$ ahead of the slowest child. It claims these nodes reduce a defined progress distance between concurrently running actions, and that placing an artificial reference action inside an absolute node can impose a desired progress profile, improving the predictability of execution time. The intended payoff is a concrete mechanism for writing synchronized parallel robot behaviors without solving concurrency by hand, and for narrowing the gap between simulated and real robot execution.

What carries the argument

The mechanism that carries the argument is the progress function $p:\mathbb{R}^n\to[0,1]$ (Definition 2), which maps the robot state to a measure of how far each child action has advanced. The absolute synchronized parallel node (Algorithm 1) uses a finite ordered set of progress barriers $B$, ticks only children whose progress has not passed the current barrier, and thereby converts a designer's barrier choices into enforced waiting points. The relative synchronized parallel node (Algorithm 2) replaces the barrier set with a single threshold $\Delta$, holding back any child that is more than $\Delta$ ahead of the minimum progress. A third device, the artificial reference action with a desired progress profile, is placed as a child of an absolute node to act as an upper bound that slower real actions must chase; since actions can only be stopped, not sped up, the reference must be an ideal upper bound. The performance measures in Eqs. (5) and (6) are what turn these node designs into quantitative claims about synchronization quality and predictability.

What would settle it

Run two actions whose progress is not monotonic, for example a re-grasp that must release and re-approach and therefore reports progress decreasing below a barrier already reached by the other child; if the measured progress distance (Eq. 5) with synchronization is not smaller than without it, or if the parallel node stalls permanently, the claim that these nodes reduce drift fails for that action class.

Watch

Extended reading notes

Core claim

The paper's central claim is that parallel Behavior Tree nodes can be made concurrency-safe by giving each child a progress value $p(x_k)\in[0,1]$ (Definition 2) and using that value to stall ticks: a fast child is simply not ticked until the others catch up. Algorithm 1 implements absolute synchronization by keeping a pre-defined ordered set of barriers $B$, finding the smallest barrier below the current minimum progress, and ticking only children at or below that barrier; Algorithm 2 implements relative synchronization by ticking only children whose progress is at most $\min_i p_i + \Delta$ for a threshold $\Delta\in[0,1]$. The paper defines progress distance $\pi(k_1,k_2)$ (Eq. 5) as the time-accumulated pairwise difference of child progress, and predictability distance $P(\bar p)$ (Eq. 6) as the deviation between the time a desired progress $\bar p$ is reached and the time it was expected. Its experiments on the R1 robot support the conclusion that more barriers and smaller $\Delta$ reduce progress distance, and that an artificial reference action can make a real action follow an imposed straight-line or sigmoid progress profile.

Load-bearing premise

The whole construction assumes every action can report a reliable, comparable progress number in $[0,1]$ to its parent; if progress is missing, non-monotonic, or measured in units that cannot be compared across actions, the barrier calculations in both algorithms cannot run as specified.

Editorial extensions

If this is right

Larger barrier sets in an absolute node, and smaller thresholds $\Delta$ in a relative node, tighten the progress distance between concurrently running actions, at the cost of a slower overall execution.
Because actions are only stopped, never accelerated, absolute synchronization can impose a desired progress profile only when the reference profile is an upper bound; the real action is held to match it.
The predictability measure $P(\bar p)$ gives designers a numeric way to compare design choices, such as the number of barriers, before running on hardware.
Synchronization extends to perpetual actions by defining progress as a binary value (1 when a state error is within bounds, 0 otherwise), so a relative node can pause base motion while an arm realigns a cart.
In simulated-versus-real transfer, an artificial reference action can make a robot that is too fast wait, reducing the difference between simulated and real progress profiles.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

If progress functions from different actions are measured in incompatible units, the pairwise comparisons in Eq. (5) require a normalization choice the paper does not address; defining per-action unit-aware progress or a learned rescaling would make the synchronization applicable across heterogeneous actuators.
The sensitivity analysis suggests an online tuning loop: adjust the barrier set $B$ or the threshold $\Delta$ based on the observed covariance of progress noise, rather than fixing them a priori, to trade off progress distance against intermittent stalling.
The predictability result implies a direct test of sim-to-real transfer: measure the time at which a real action crosses each $\bar p$ both with and without an artificial reference action; if the reference bounds the real progress, the predictability distance should shrink, which is a measurable claim the paper's experiments only partially exercise.
A weighted version of progress distance, giving more weight to safety-critical children, would let designers allow slack in unimportant actions while keeping critical motion tightly aligned; the current measure weights all children equally.

Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

What you should know: this is a legitimate incremental contribution to Behavior Tree concurrency. The absolute synchronized parallel node (Algorithm 1) is new, the relative node is carried over from the authors' IROS 2018 paper, and the two proposed measures (progress distance and predictability distance) are genuinely useful for thinking about design choices. The central idea is sound and the real-robot examples are easy to follow.

What the paper does well: it gives a clear pseudocode formulation of both nodes, shows how an artificial reference action can impose a desired progress profile, and provides a sensitivity analysis plus several experiments. The observation that more barriers or a smaller Delta reduce progress distance is a direct consequence of the algorithms, but it is still worth stating quantitatively for designers. The R1 experiments are plausible and the video links help.

Soft spots, in rough order of importance. First, Definition 2 does not require progress to be monotone, yet the prose around both algorithms says a node that has crossed a barrier or exceeded the minimum by Delta “no longer receives ticks.” As written, the algorithms use the current progress each tick, so a non-monotone progress function can cause a child to be ticked again after it drops below the barrier. For the binary perpetual-action experiment this is actually the desired behavior, but the text overstates the guarantee. That is a formal framing issue, not a fatal one. Second, Algorithm 1 has a real bug: minProgress is used before initialization, and the behavior when minProgress >= max(B) is undefined. Minor, but needs fixing. Third, the predictability distance in Definition 5 is ambiguous: argmin over what set, and what is the expected time t_k_bar? It needs a precise definition. Fourth, the paper claims “statistically-significant data” without any p-values, confidence intervals, or test names; 100 or 1000 runs are fine, but the claim is unsupported. Fifth, the novelty statement in Related Work overreaches—there is prior work on BT parallel composition and their own prior relative node.

Who this is for: researchers working on Behavior Tree semantics, robotic task coordination, or predictable action execution. It deserves a serious peer review: the algorithms are simple but useful, and the issues are fixable. I would send it to review with a request to tighten the formal definitions, fix the pseudocode, and soften the statistical and novelty claims.

Referee Report

5 major / 4 minor

Summary. The paper proposes two synchronized parallel node designs for Behavior Trees: an absolute node that ticks children only until they reach a pre-specified progress barrier (Algorithm 1), and a relative node that withholds ticks from children whose progress exceeds the current minimum by a threshold Delta (Algorithm 2). It defines a progress-distance measure (Eq. 5) and a predictability-distance measure (Eq. 6), presents sensitivity analyses over the number of barriers, noise level, and threshold, and reports simulations and R1 robot experiments to support the claim that synchronization improves behavior predictability.

Significance. If the definitions were made precise, the paper would be a useful step toward principled parallel composition in Behavior Trees: the proposed nodes are simple, the progress-distance measure is natural, and the real-robot experiments give the work an applied anchor. The paper also gives explicit credit to prior work and includes a public video of the experiments. However, the formal gaps described below currently affect the central algorithmic claims and the quantitative evaluation, so the significance is contingent on those fixes.

major comments (5)

[Section IV-A, Algorithm 1] Algorithm 1 is not well-defined as written. The variable minProgress is used at Lines 2-3 but is never initialized, so on the first tick min(minProgress, pi) is undefined unless an external convention is assumed. In addition, if no barrier b in B satisfies b > minProgress, which occurs for the baseline |B| = 0 used in Figures 1 and 3 and for any execution that has reached the largest barrier, current-barrier remains undefined and Lines 8-10 cannot be evaluated. The pseudocode should specify initialization and define the behavior when all barriers have been crossed.
[Section IV, Definition 2] The synchronization semantics implicitly require monotone progress, but Definition 2 only states that p maps states into [0,1] and does not require monotonicity. For a non-monotonic progress function, a child that has crossed a barrier can later fall below it and be ticked again, contradicting the statement in Section IV-A that a node 'no longer receives ticks until all the other nodes... have the progress equal to or greater than the barrier.' The same issue affects Algorithm 2, where 'exceeds the minimum progress by Delta' is not a persistent condition if the minimum can regress. Experiment 3 deliberately uses a binary, non-monotonic progress signal, so the paper's own experimental scenario falls outside the regime where the stated semantics hold. The authors should either restrict the framework to monotone progress functions or redefine the synchronization condition to handle decreasing progress explicitly.
[Section V-C, Eqs. (7)-(9)] The synthetic progress models in Eqs. (7)-(9) do not respect the codomain [0,1] imposed by Definition 2. With alpha values of 1, 2, and 5, the progress values exceed 1 after a single tick unless additional saturation or termination semantics are specified, and no such specification is given. Since the sensitivity analysis and Figures 1-3 are based on these equations, the quantitative conclusions are currently not supported by a valid progress model. The update rules need to be clamped or redefined so that p(x_k) always lies in [0,1].
[Section V-B, Definition 5] Definition 5 is not mathematically well-defined. The expression tk = argmin(p(x(tk)) - pbar) is missing a minimization domain and an absolute value; it should presumably be 'tk minimizes |p(x(tk)) - pbar| over the sampled time instants.' The set T_pbar is then described as a set of such time instances, but taking a mean of argmin results is not a standard operation, and the expected time tbar_k is not defined anywhere. Without a precise definition of T_pbar and tbar_k, Eq. (6) cannot be computed, which undermines the predictability experiments in Example 7, Experiment 4, and Figure 3.
[Section VI and abstract] The abstract and Section VI claim that the experiments yield 'statistically-significant data,' but no statistical test, p-value, confidence interval, or effect-size measure is reported. The boxplots in Figures 1-4 and 6-8 are descriptive only, so the significance claim is unsupported. The authors should either state the hypothesis being tested and report the corresponding test results, or soften the claim to 'descriptive statistics from repeated runs.'

minor comments (4)

[Section IV-B, Algorithm 2] Line 6 of Algorithm 2 contains a typo: 'minProgrees' should be 'minProgress'.
[Section VI, Figure 5 caption] The caption of Figure 5 says 'BT for Experiment 3,' but the figure and surrounding text describe Experiment 4 (Predictability). The caption should refer to Experiment 4.
[Section V-C.3] The text says 'We observe worse performance with larger ¯ω and Δ' in the discussion of how the number of barriers affects predictability, but the experiment varies |B|, not Δ; the sentence should refer to the number of barriers.
[Throughout] There are several typos and grammatical slips, including 'Predictabity' in the Section IV-C heading, 'for we ran each experiment' in Section VI, and 'diaogues' in Section I. A careful proofreading pass is needed.

Circularity Check

2 steps flagged · score 6.0 of 10

Progress-distance and predictability improvements are encoded in the algorithms' own tick-stopping rules rather than independently validated.

self definitional [Section V-C.1 (Definition 4, Eq. 5; Algorithm 1 Lines 4-10)]
"The progress distance over a time window [k1,k 2] for a parallel node with N children is defined as: π(k1,k 2)≜∑ |pi(xk)−pj(xk)| / 2 (5). ... We observe higher performance with a large number of barriers and smaller ¯ω. This highlights that a higher number of barriers prevents the progress of the actions to differ from each other (see Algorithm 1 Line 5 and 9-10)."

Eq. 5 is a sum of pairwise |pi−pj| progress differences. Algorithm 1's gate (Lines 4-10) freezes every child with p_i above the currently selected barrier until the slowest child reaches it, and Algorithm 2 freezes children above minProgress+Δ. Hence the admissible spread of progress values is bounded by the barrier spacing or Δ. Varying |B| or Δ changes that bound directly; the measured progress distance is therefore the same quantity the tick rule was written to constrain. The experiments redraw the construction rather than testing it against an external benchmark.
self definitional [Section IV-C and Section VI Experiment 4 (Definition 5, Eq. 6; Algorithm 1)]
"Progress synchronization can be used to impose a given progress profile constraint. The idea is to define an artificial action with the desired progress profile (over time) defined a priori and putting it as a child of an absolute synchronized parallel node with the actions whose progress is to be constrained. ... The time predictability distance relative to progress ¯p is defined as: P (¯p)≜mean(T ¯p)− ¯tk (6)."

Definition 5's P(¯p) measures when the real action reaches progress ¯p against an expected time. In Experiment 4 that expected time comes from the artificial reference action placed inside the same absolute node, and Algorithm 1 stops the real action whenever its progress would exceed the reference-imposed barrier. Thus the 'real' progress curve is actively prevented from leading the 'Reference' curve; the small predictability distance is a consequence of the feedback law encoded in Algorithm 1, not an independent prediction of execution timing.

full rationale

The paper proposes two tick-stalling control-flow nodes and defines progress-distance and predictability metrics that quantify exactly the quantities those nodes were designed to constrain. The sensitivity results (more barriers or smaller Δ reduce progress distance) are direct consequences of the if-statements in Algorithms 1 and 2, so the simulations confirm the construction rather than testing it against independent data. Likewise, the predictability experiment imposes the reference profile by inserting the reference action as a child of the same absolute node, making the match between 'Reference' and 'Real' a closed-loop effect rather than an external validation. The self-citations to [13] provide the background progress-function definition and prior relative synchronization work, but they are not used as an unverified uniqueness theorem or as the sole support for the central claim; the circularity is concentrated in the self-evaluation metrics, not in a self-citation chain. The proposed nodes may still be useful engineering mechanisms, but the empirical 'performance' evidence largely restates the algorithms' intended behavior.

Assumptions & free parameters 4 free parameters · 5 assumptions · 0 invented entities

The core assumptions are the availability and comparability of per-action progress values, plus the standard BT tick model. The synthetic models and design parameters in the examples are experimental choices rather than universal inputs. No new physical entities are introduced; the synchronized parallel nodes are control-flow constructs within the BT formalism.

free parameters (4)

alpha_i for synthetic actions = alpha_1=1, alpha_2=2, alpha_3=5
Chosen by hand in Examples 5 and 6 to model actions with different speeds; the qualitative conclusions of the sensitivity analysis do not depend on the exact values.
noise bound omega_bar = 0, 1, 2, 5
Chosen by hand to model execution uncertainty in the synthetic examples; swept to show its effect on progress distance.
number of barriers |B| = varies (equidistant; e.g., 50 in Experiment 4)
Design parameter of absolute synchronization, swept to show how it affects progress distance and predictability.
relative threshold Delta = varies in [0,1]
Design parameter of relative synchronization, swept to show how it affects progress distance.

assumptions (5)

standard math The standard Behavior Tree state-space formulation from Colledanchise and Oegren [12] (Definition 1) describes BT execution as a recursive tick function with a state update equation.
The entire framework builds on this model, including the tick semantics and the definition of progress.
domain assumption Every action can expose a progress function p(x_k) in [0,1] to its parent node (Definition 2 from [13]).
This is the key enabling assumption for both synchronization algorithms and the performance measures. It is not part of classical BT semantics and may not hold for all real actions.
domain assumption Progress values of different actions are normalized to [0,1] and directly comparable.
The algorithms compare min progress and barrier values across children; if progress units differ across actions (e.g., joint angle versus distance), the synchronization semantics are unclear.
ad hoc to paper The predictability measure (Definition 5) assumes a well-defined expected time t_bar_k when progress equals a given value, and that the argmin over sampled times is meaningful and unique enough for a mean to be computed.
The definition relies on an expectation that is not formally tied to the BT dynamics, and the argmin may be non-unique in practice.
ad hoc to paper The synthetic progress model in Eq. (7) with constant increments plus uniform noise is used for the sensitivity analysis.
This model is chosen for illustration and is not derived from first principles or empirical data.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Analysis and Exploitation of Synchronized Parallel Executions in Behavior Trees." pith.science (2026). https://pith.science/paper/KFILBDTU

@misc{pith2026190801539,
  author       = {Pith},
  title        = {Pith review of: Analysis and Exploitation of Synchronized Parallel Executions in Behavior Trees},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/KFILBDTU}},
  note         = {Machine review of arXiv:1908.01539}
}

read the original abstract

Behavior Trees (BTs) are becoming a popular tool to model the behaviors of autonomous agents in the computer game and the robotics industry. One of the key advantages of BTs lies in their composability, where complex behaviors can be built by composing simpler ones. The parallel composition is the one with the highest potential since the complexity of composing pre-existing behaviors in parallel is much lower than the one needed using classical control architectures as finite state machines. However, the parallel composition is rarely used due to the underlying concurrency problems that are similar to the ones faced in concurrent programming. In this paper, we define two synchronization techniques to tackle the concurrency problems in BTs compositions and we show how to exploit them to improve behavior predictability. Also, we introduce measures to assess execution performance, and we show how design choices can affect them. To illustrate the proposed framework, we provide a set of experiments using the R1 robot and we gather statistically-significant data.

Figures

Figures reproduced from arXiv: 1908.01539 by the authors.

**Figure 2.** Plotbox for progress distance of Example 6 with different [PITH_FULL_IMAGE:figures/full_fig_p005_2.png] view at source ↗

**Figure 3.** Plotbox for predictability distance for Example 7. [PITH_FULL_IMAGE:figures/full_fig_p006_3.png] view at source ↗

Figures from the paper (2 more)

**Figure 5.** Figure 5: BT and progress profiles for Experiment 4. [PITH_FULL_IMAGE:figures/full_fig_p007_5.png]

**Figure 7.** Figure 7: Execution steps related to Experiment 3. [PITH_FULL_IMAGE:figures/full_fig_p008_7.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

23 extracted references · 23 canonical work pages

[1]

Extended behavior trees for quick deﬁnition of ﬂexible robotic tasks,

F. Rovida, B. Grossmann, and V . Krüger, “Extended behavior trees for quick deﬁnition of ﬂexible robotic tasks,” in 2017 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS) . IEEE, 2017, pp. 6793–6800

work page 2017
[2]

IKBT: Solving Symbolic Inverse Kine- matics with Behavior Tree,

D. Zhang and B. Hannaford, “IKBT: Solving Symbolic Inverse Kine- matics with Behavior Tree,”Journal of Artiﬁcial Intelligence Research, vol. 65, pp. 457–486, 2019

work page 2019
[3]

Development of Intelligent Behaviors for Social Robots via User-Friendly and Modular Programming Tools,

E. Coronado, F. Mastrogiovanni, and G. Venture, “Development of Intelligent Behaviors for Social Robots via User-Friendly and Modular Programming Tools,” in 2018 IEEE Workshop on Advanced Robotics and its Social Impacts (ARSO) . IEEE, 2018, pp. 62–68

work page 2018
[4]

Costar: Instructing Collaborative Robots with Behavior Trees and Vision,

C. Paxton, A. Hundt, F. Jonathan, K. Guerin, and G. D. Hager, “Costar: Instructing Collaborative Robots with Behavior Trees and Vision,” in 2017 IEEE International Conference on Robotics and Automation (ICRA). IEEE, 2017, pp. 564–571

work page 2017
[5]

An IDE for Easy Programming of Simple Robotics Tasks,

D. Shepherd, P. Francis, D. Weintrop, D. Franklin, B. Li, and A. Afzal, “An IDE for Easy Programming of Simple Robotics Tasks,” in 2018 IEEE 18th International Working Conference on Source Code Analysis and Manipulation (SCAM) . IEEE, 2018, pp. 209–214

work page 2018
[6]

A Hybrid Approach to Planning and Execution in Dynamic Environments Through Hierar- chical Task Networks and Behavior Trees,

X. Neufeld, S. Mostaghim, and S. Brand, “A Hybrid Approach to Planning and Execution in Dynamic Environments Through Hierar- chical Task Networks and Behavior Trees,” in Fourteenth Artiﬁcial Intelligence and Interactive Digital Entertainment Conference , 2018

work page 2018
[7]

Adding Neural Network Controllers to Behavior Trees without Destroying Performance Guarantees

C. I. Sprague and P. Ögren, “Adding Neural Network Controllers to Behavior Trees without Destroying performance guarantees,” arXiv preprint arXiv:1809.10283, 2018

work page Pith review arXiv 2018
[8]

Autonomous Acquisition of Behavior Trees for Robot Control,

B. Banerjee, “Autonomous Acquisition of Behavior Trees for Robot Control,” in 2018 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS) . IEEE, 2018, pp. 3460–3467

work page 2018

Show all 23 references

[9]

Hidden Markov Models derived from Behavior Trees,

B. Hannaford, “Hidden Markov Models derived from Behavior Trees,” arXiv preprint arXiv:1907.10029 , 2019

1907 arXiv
[10]

Improving the Modularity of AUV Control Systems using Behaviour Trees,

C. I. Sprague, Ö. Özkahraman, A. Munafo, R. Marlow, A. Phillips, and P. Ögren, “Improving the Modularity of AUV Control Systems using Behaviour Trees,” arXiv preprint arXiv:1811.00426 , 2018

2018 arXiv
[11]

Increasing Modularity of UA V Control Systems using Computer Game Behavior Trees,

P. Ögren, “Increasing Modularity of UA V Control Systems using Computer Game Behavior Trees,” in AIAA Guidance, Navigation and Control Conference, Minneapolis, MN , 2012

2012
[12]

Colledanchise and P

M. Colledanchise and P. Ögren, Behavior Trees in Robotics and AI: An Introduction , ser. Chapman and Hall/CRC Artiﬁcial Intelligence and Robotics Series. Taylor & Francis Group, 2018

2018
[13]

Improving the Parallel Execution of Behavior Trees,

M. Colledanchise and L. Natale, “Improving the Parallel Execution of Behavior Trees,” in 2018 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS) . IEEE, 2018, pp. 7103–7110

2018
[14]

Motion Generators Combined with Behavior Trees: A Novel Ap- proach to Skill Modelling,

F. Rovida, D. Wuthier, B. Grossmann, M. Fumagalli, and V . Krüger, “Motion Generators Combined with Behavior Trees: A Novel Ap- proach to Skill Modelling,” in 2018 IEEE/RSJ International Confer- ence on Intelligent Robots and Systems (IROS) , pp. 5964–5971

2018
[15]

A Robust Layered Control System for a Mobile Robot,

R. Brooks, “A Robust Layered Control System for a Mobile Robot,” IEEE journal on robotics and automation , vol. 2, no. 1, pp. 14–23, 1986

1986
[16]

The Impact of the Contingency of Robot Feedback on HRI,

K. Fischer, K. Lohan, J. Saunders, C. Nehaniv, B. Wrede, and K. Rohlﬁng, “The Impact of the Contingency of Robot Feedback on HRI,” in 2013 International Conference on Collaboration Technolo- gies and Systems (CTS) . IEEE, 2013, pp. 210–217

2013
[17]

Vision- based Contingency Detection,

J. Lee, J. F. Kiser, A. F. Bobick, and A. L. Thomaz, “Vision- based Contingency Detection,” in Proceedings of the 6th international conference on Human-robot interaction . ACM, 2011, pp. 297–304

2011
[18]

Towards a Com- mon Framework for Multimodal Generation: The Behavior Markup Language,

S. Kopp, B. Krenn, S. Marsella, A. N. Marshall, C. Pelachaud, H. Pirker, K. R. Thórisson, and H. Vilhjálmsson, “Towards a Com- mon Framework for Multimodal Generation: The Behavior Markup Language,” in International workshop on intelligent virtual agents . Springer, 2006, pp. 205–217

2006
[19]

Enabling Concurrency in your Behavior Hierar- chy,

A. Champandard, “Enabling Concurrency in your Behavior Hierar- chy,” AIGameDev. com, 2007

2007
[20]

Reactive Plan- ning Idioms for Multi-scale Game AI,

B. G. Weber, P. Mawhorter, M. Mateas, and A. Jhala, “Reactive Plan- ning Idioms for Multi-scale Game AI,” in Computational Intelligence and Games (CIG), 2010 IEEE Symposium on , pp. 115–122

2010
[21]

A Behavior Language for Story-based Believable Agents,

M. Mateas and A. Stern, “A Behavior Language for Story-based Believable Agents,” IEEE Intelligent Systems , vol. 17, no. 4, 2002

2002
[22]

The Advantages of using Behavior Trees in Multi-robot Systems,

M. Colledanchise, A. Marzinotto, D. V . Dimarogonas, and P. Ögren, “The Advantages of using Behavior Trees in Multi-robot Systems,” in ISR 2016: 47st International Symposium on Robotics; Proceedings of

2016
[23]

Taubenfeld, Synchronization Algorithms and Concurrent Program- ming

G. Taubenfeld, Synchronization Algorithms and Concurrent Program- ming. Pearson Education, 2006

2006

Pith tools

Reviewed August 14, 2026 · model on record in the stance chip above.

[1] [1]

Extended behavior trees for quick deﬁnition of ﬂexible robotic tasks,

F. Rovida, B. Grossmann, and V . Krüger, “Extended behavior trees for quick deﬁnition of ﬂexible robotic tasks,” in 2017 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS) . IEEE, 2017, pp. 6793–6800

work page 2017

[2] [2]

IKBT: Solving Symbolic Inverse Kine- matics with Behavior Tree,

D. Zhang and B. Hannaford, “IKBT: Solving Symbolic Inverse Kine- matics with Behavior Tree,”Journal of Artiﬁcial Intelligence Research, vol. 65, pp. 457–486, 2019

work page 2019

[3] [3]

Development of Intelligent Behaviors for Social Robots via User-Friendly and Modular Programming Tools,

E. Coronado, F. Mastrogiovanni, and G. Venture, “Development of Intelligent Behaviors for Social Robots via User-Friendly and Modular Programming Tools,” in 2018 IEEE Workshop on Advanced Robotics and its Social Impacts (ARSO) . IEEE, 2018, pp. 62–68

work page 2018

[4] [4]

Costar: Instructing Collaborative Robots with Behavior Trees and Vision,

C. Paxton, A. Hundt, F. Jonathan, K. Guerin, and G. D. Hager, “Costar: Instructing Collaborative Robots with Behavior Trees and Vision,” in 2017 IEEE International Conference on Robotics and Automation (ICRA). IEEE, 2017, pp. 564–571

work page 2017

[5] [5]

An IDE for Easy Programming of Simple Robotics Tasks,

D. Shepherd, P. Francis, D. Weintrop, D. Franklin, B. Li, and A. Afzal, “An IDE for Easy Programming of Simple Robotics Tasks,” in 2018 IEEE 18th International Working Conference on Source Code Analysis and Manipulation (SCAM) . IEEE, 2018, pp. 209–214

work page 2018

[6] [6]

A Hybrid Approach to Planning and Execution in Dynamic Environments Through Hierar- chical Task Networks and Behavior Trees,

X. Neufeld, S. Mostaghim, and S. Brand, “A Hybrid Approach to Planning and Execution in Dynamic Environments Through Hierar- chical Task Networks and Behavior Trees,” in Fourteenth Artiﬁcial Intelligence and Interactive Digital Entertainment Conference , 2018

work page 2018

[7] [7]

Adding Neural Network Controllers to Behavior Trees without Destroying Performance Guarantees

C. I. Sprague and P. Ögren, “Adding Neural Network Controllers to Behavior Trees without Destroying performance guarantees,” arXiv preprint arXiv:1809.10283, 2018

work page Pith review arXiv 2018

[8] [8]

Autonomous Acquisition of Behavior Trees for Robot Control,

B. Banerjee, “Autonomous Acquisition of Behavior Trees for Robot Control,” in 2018 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS) . IEEE, 2018, pp. 3460–3467

work page 2018