Branch Model Predictive Control (BMPC)

Updated 7 July 2026

Branch Model Predictive Control is a tree-structured approach that creates a contingent policy tree with a common prefix before distinct branches emerge.
It enables conditional adaptation in applications like automated driving by optimizing branch-specific trajectories based on predicted agent behaviors.
BMPC balances nominal and robust MPC by enforcing non-anticipativity, leveraging scenario selection and risk measures, and exploiting parallel computation for real-time efficiency.

Branch Model Predictive Control (BMPC), also called Branch MPC, is a tree-structured form of model predictive control for systems facing discrete, multi-modal uncertainty. Instead of optimizing one nominal future trajectory, BMPC optimizes a contingent policy represented as a trajectory tree: a common prefix is shared while uncertainty remains unresolved, and branch-specific continuations are optimized for different future realizations once they become distinguishable. In automated driving, this structure is used to represent alternatives such as yielding versus asserting at an intersection, slowing down versus maintaining speed in a merge, or different learned prediction modes of surrounding vehicles. BMPC is therefore positioned between nominal MPC, which commits to one future, and robust MPC, which maintains one trajectory that must hedge against all futures over the full horizon; its central advantage is that it preserves non-anticipativity through the shared prefix while allowing future adaptation after information is expected to arrive (Zhang et al., 16 Jun 2025, Chen et al., 2021).

1. Conceptual basis and historical framing

BMPC is motivated by planning problems in which uncertainty is not merely continuous disturbance but has a discrete behavioral structure. In interactive driving, an uncontrolled agent may maintain speed, slow down, stop, change lane, yield, or proceed; these are qualitatively different futures rather than perturbations around a single nominal motion. BMPC addresses this by constructing a scenario tree for the uncertain environment and optimizing a matching ego trajectory tree with the same topology (Chen et al., 2021).

The defining control-theoretic feature is non-anticipativity. Before the uncertain behavior is resolved or observed, controls that correspond to futures sharing the same information must be identical. BMPC can enforce this either structurally, by sharing nodes in a tree representation, or explicitly, by imposing common-trunk equality constraints such as $u_s(t)=\tilde u(t)$ for all hypotheses $s$ before a branching stage $L$ (Zhang et al., 16 Jun 2025, Phiquepal et al., 2023). In the tree formulation of nonlinear BMPC, all scenarios that share a node share the same state and input decision there, so non-anticipativity is built into the representation rather than imposed as separate equality constraints (Zhang et al., 16 Jun 2025).

This perspective differs from both nominal and robust formulations. Nominal MPC optimizes a single trajectory under one predicted future. Robust MPC protects against all possibilities simultaneously and is often too conservative in interactive settings because it ignores that future observations can disambiguate the situation. BMPC instead optimizes conditional future actions: one action now, different admissible continuations later, depending on which branch materializes (Chen et al., 2021, Bouzidi et al., 2024).

A related but distinct line of work uses the same tree idea for discrete partial observability rather than reactive agents. In “control-tree optimization,” the uncertainty is a partially observed discrete latent state $s\in S$ , the controller maintains a belief distribution $p(s)$ , and the optimized policy has a common trunk followed by hypothesis-dependent branches. This leads to belief-weighted performance while still enforcing robust constraint satisfaction across all hypotheses (Phiquepal et al., 2023).

2. Mathematical structure and canonical formulations

A general BMPC tree can be described by a node set $\mathcal N$ , root node $0$, leaf set $\mathcal L$ , and level sets $\mathcal N_k$ . For each non-leaf node $i$ , the data include $s$ 0, where $s$ 1, $s$ 2, $s$ 3 is the transition probability from the parent, $s$ 4 are nonlinear dynamics, $s$ 5 stage costs, and $s$ 6 inequality constraints. The optimization variables are the full state and input trees,

$s$ 7

and the BMPC problem takes the weighted-sum form

$s$ 8

subject to the root condition, parent-to-child dynamics, and stage or terminal inequality constraints (Zhang et al., 16 Jun 2025).

For interactive motion planning, a common formulation is branch-wise rather than node-wise. Given a branch index set $s$ 9, branch trajectories $L$ 0, branch costs $L$ 1, branch constraints $L$ 2, and branch probabilities $L$ 3, the optimization minimizes

$L$ 4

subject to within-branch dynamics, continuity between parent and child branches, probability propagation, and initial conditions. Here $L$ 5 includes slack penalties for branch-local constraint violations (Chen et al., 2021).

For discrete partial observability, the control-tree form is especially compact. With belief $L$ 6 over hypotheses $L$ 7, common controls $L$ 8 on the trunk, branch controls $L$ 9, and branch states $s\in S$ 0, the optimization is

$s\in S$ 1

subject to per-hypothesis dynamics and constraints, plus the non-anticipativity constraint $s\in S$ 2 for $s\in S$ 3 (Phiquepal et al., 2023).

Across these formulations, the same structural principles recur. The objective is a weighted sum over branches or nodes; constraints are enforced on each branch; and the shared prefix encodes what can be done before future information is available. This is why BMPC is best understood as optimizing a feedback policy in finite-dimensional tree form rather than a single open-loop sequence (Chen et al., 2021).

3. Uncertainty models, branch construction, and risk treatment

Branches can be generated from several kinds of uncertainty abstractions. In interactive driving, one approach is to specify a finite policy set for the uncontrolled agent,

$s\in S$ 4

together with a predictive model $s\in S$ 5. The scenario tree is then built by branching over these policies at designated branching nodes, and the ego solves for a trajectory tree with the same topology (Chen et al., 2021). In decision-aware driving, branches correspond more specifically to human policies or decisions such as speed up, keep speed, slow down, cross, or stop, often with branch probabilities produced by a behavioral model that depends on the traffic scene and can therefore depend on the ego plan itself (Oliveira et al., 2023).

A second branch-construction route starts from learned multi-modal predictors. A predictor such as Motion Transformer may output a Gaussian mixture of future modes for each surrounding object. BMPC then requires scenario selection, because using every raw mode directly leads to an impractically large tree. One approach clusters prediction modes by topology and collision risk, keeping a minimal set of planner-relevant scenarios and then estimating a branching time from Bhattacharyya distance between Gaussian modes (Bouzidi et al., 2024). A later reachability-based formulation maps each predicted mode into one or more ego driving corridors, merges or prunes corridors by overlap while preserving coverage of all modes, and uses the retained corridors directly as BMPC branches; it also computes the maximum feasible decision-postponing time so that branching remains executable (Bouzidi et al., 4 Feb 2025).

Risk treatment varies across formulations. The basic BMPC objective is expectation over branches. A risk-averse extension replaces expectation with coherent risk measures, especially CVaR, so that branch probabilities can be adversarially perturbed within an ambiguity set. In the scenario-tree setting this becomes a nested risk measure, preserving time consistency across branching stages (Chen et al., 2021). Another extension combines branching with stochastic MPC: branch-specific trajectories are optimized for clusters of intention scenarios, while chance constraints remain active within each branch to account for trajectory uncertainty around a nominal predicted mode. This separates intention uncertainty, handled by branching, from trajectory uncertainty, handled by chance constraints (Xing et al., 21 May 2026).

The partial-observability literature adopts a different compromise: performance is belief-weighted, but safety constraints are enforced for every discrete hypothesis. The common trunk is therefore constrained by the active constraints of all states regardless of state likelihood, which guarantees robust constraint satisfaction while avoiding pure worst-case cost optimization (Phiquepal et al., 2023).

4. Numerical methods and computational structure

Nonlinear BMPC is commonly solved by sequential local approximation. A recent formulation uses an iLQR-style sequential quadratic approximation on the tree: around a nominal tree $s\in S$ 6, it constructs an LQR-Tree problem in perturbations $s\in S$ 7, where the local dynamics are linearized and the local cost is quadraticized via the Lagrangian gradient and Hessian along the tree (Zhang et al., 16 Jun 2025).

The main computational challenge is that the tree introduces coupling across time and scenarios. A key result is that the usual sequential Riccati recursion for linear-quadratic control can be reformulated through conditional value functions and associative composition rules, so the backward pass becomes compatible with a parallel scan. This reduces the sequential depth from $s\in S$ 8 to $s\in S$ 9 for a linear chain and generalizes to tree-structured BMPC by separating the leaves-to-last-branch part from the shared prefix (Zhang et al., 16 Jun 2025).

In that GPU-oriented solver, the tree is decomposed into two pieces. The suffix $p(s)$ 0, from leaves back to the last branching time step $p(s)$ 1, consists of independent leaf-to-branch paths; this part is parallelized across scenarios and across time within each scenario by scan. The prefix $p(s)$ 2, from the root to the last branch, is smaller but coupled. Two alternatives are proposed for $p(s)$ 3: a sparse tree Riccati recursion, sequential in time but parallel across branches, and a condensed dense tree solve, useful when the shared prefix is small enough that GPU dense linear algebra dominates (Zhang et al., 16 Jun 2025).

Inequality constraints in this solver are handled by an augmented Lagrangian wrapped around the tree iLQR inner loop. The architecture is explicitly double-loop: the outer loop updates multipliers and penalties, and the inner loop solves the relaxed equality-constrained BMPC. To keep the local quadratic model well behaved, a generalized Gauss–Newton Hessian approximation is used. The implementation is in JAX, with dense factorizations delegated to cuSolver (Zhang et al., 16 Jun 2025).

Other numerical strategies reflect the underlying uncertainty model. Branch MPC with policy-dependent branch probabilities has been solved by SQP, linearizing not only dynamics and constraints but also the weighted branch costs $p(s)$ 4. In that setting, expectation-based formulations were solved with OSQP and CVaR-based formulations with ECOS after conic reformulation (Chen et al., 2021). Control-tree optimization for discrete partial observability uses a decomposition across hypotheses: each branch subproblem is handled separately, while the common trunk is enforced by augmented-Lagrangian/ADMM-style consensus updates. The expensive branchwise minimizations are parallelizable, and the reported convergence is typically after 10 to 30 iterations (Phiquepal et al., 2023).

A central practical lesson is that BMPC becomes computationally effective only when the tree structure is exploited directly. Flattening the problem into loosely coupled scenarios with explicit non-anticipativity constraints is possible, but recent solver work argues that solving directly on the tree and separating a highly parallel suffix from a smaller coupled prefix is more favorable, especially on GPUs and for long horizons or many leaves (Zhang et al., 16 Jun 2025).

5. Applications and observed behavior

BMPC has been evaluated across interactive driving, autonomous robotics, and partially observed safety-critical control. The most recurrent application domain is automated driving, where surrounding vehicles exhibit multi-modal intentions and the ego should plan conditionally rather than conservatively.

Setting	BMPC role	Reported outcome
Overtake, lane change, merge, intersection	Trajectory tree over reactive human modes	Human-like, assertive, intent-shaping behavior (Chen et al., 2021, Oliveira et al., 2023)
Pedestrian crossing, uncertain obstacles	Control tree over discrete hypotheses	Better control costs than single-hypothesis MPC; real-time at 10 Hz (Phiquepal et al., 2023)
Multi-modal learned traffic prediction	Scenario-selected or corridor-clustered BMPC	Improved safety, comfort, and real-time tractability (Bouzidi et al., 2024, Bouzidi et al., 4 Feb 2025)

In interactive driving with hand-specified behavior modes, BMPC produced characteristic contingent maneuvers. In an overtake-and-lane-change task, the ego initially performed a “nudging” maneuver rather than committing immediately, because the gradient term associated with branch-probability linearization allowed it to reduce the probability of a dangerous lane-change branch before overtaking. In a merging task, the planner carried both “merge ahead if the other slows down” and “merge behind if the other maintains speed” as simultaneous contingencies (Chen et al., 2021). In related decision-aware experiments, the planner could become more assertive when its motion increased the modeled probability that the human driver would yield (Oliveira et al., 2023).

In discrete partial observability, the control-tree approach was evaluated on adaptive cruise control among pedestrians and slalom with uncertain obstacles. The reported planning rate was 10 Hz with a 5-second horizon and 4 steps/s. In the pedestrian case, control trees always led to better control costs than the single-hypothesis MPC, with the benefit most significant when crossing probability was low. In the slalom example, tree-4 planning times were 59.3 ms and 74.2 ms, compared with 27.7 ms and 32.8 ms for the single-hypothesis baseline, while average costs moved substantially closer to the full-information lower bound (Phiquepal et al., 2023).

For learned traffic prediction, scenario selection and adaptive branching time are decisive. In a traffic-intersection study using a predictor with multiple modes, the full framework selected two relevant scenarios and estimated a branching time $p(s)$ 5 s. In 100 random highway merging scenarios with horizon $p(s)$ 6, sample time $p(s)$ 7 ms, and scenario cap $p(s)$ 8, the full framework achieved 94% success, 5% aborted maneuvers, 1% collisions, mean cost 575.5, and mean solving time $p(s)$ 9 ms, outperforming a conventional single-scenario MPCC and several BMPC ablations (Bouzidi et al., 2024). A reachability-based corridor variant reported runtimes under 100 ms in a complex intersection with 12 traffic participants and, in 100 Monte Carlo merging scenarios with 3 traffic participants, achieved 96% success and 0% collision with $\mathcal N$ 0 ms for the 2-scenario version (Bouzidi et al., 4 Feb 2025).

The recent GPU solver study focused less on behavior and more on numerical scaling. In an unsignalized intersection with trees of $\mathcal N$ 1 leaves and horizons $\mathcal N$ 2, the proposed parallel backward pass surpassed CPU sequential methods for long horizons, and PMSiLQR achieved about $\mathcal N$ 3 speedup at $\mathcal N$ 4 and about $\mathcal N$ 5 speedup for 12 leaf nodes. At the same time, CPU methods remained advantageous for short-horizon problems, and medium-scale tree prefixes were identified as a remaining bottleneck (Zhang et al., 16 Jun 2025).

The current BMPC literature exposes a consistent set of limitations. The first is combinatorial growth: the number of branches grows with the number of policies, hypotheses, or interacting agents, and with the number of branching stages. This is explicit in both interactive Branch MPC and discrete-partial-observability control trees. Practical systems therefore rely on truncated trees, branching every $\mathcal N$ 6 steps, one-time branching, or aggressive scenario selection and clustering (Chen et al., 2021, Phiquepal et al., 2023).

A second limitation is dependence on the uncertainty model. Interactive BMPC requires a finite policy library and a predictive model for branch probabilities; performance can degrade if the policy set omits realized behaviors or if branch probabilities are poorly calibrated. Risk-averse CVaR formulations partly address probability misspecification, but they do not remove dependence on model structure (Chen et al., 2021). Predictor-integrated BMPC similarly depends on the coverage and quality of learned multi-modal forecasts, and the scenario-selection stage can fail if planner-relevant but low-probability behaviors are discarded (Bouzidi et al., 2024, Bouzidi et al., 4 Feb 2025).

A third limitation concerns branch timing. Fixed branching schedules are simple but often unrealistic. Several papers therefore compute branching time adaptively—by Bhattacharyya distance between Gaussian predictions, by reachability-based executable postponement analysis, or by DTW-based separation metrics. These methods make branch timing scene-dependent, but they remain external heuristics rather than optimization variables in the main control problem (Bouzidi et al., 2024, Bouzidi et al., 4 Feb 2025, Xing et al., 21 May 2026).

There is also a terminological misconception worth resolving. In Branch Model Predictive Control, “branch” refers to a branching policy or trajectory tree over future uncertainties. This differs from the mixed-integer MPC literature, where branching typically refers to branch-and-bound over integer decision variables inside an MIQP or MI-NLP solver. That solver literature is highly relevant to hybrid MPC, obstacle avoidance, and logic-based control, but it addresses a different notion of branching than the scenario-tree or policy-tree structure of BMPC (Hespanhol et al., 2019, Quirynen et al., 2022, Mitrai et al., 2023).

Finally, several open directions are stated explicitly in the source papers. For BMPC under learned traffic prediction, multi-stage or repeated branching remains largely unaddressed in real time. For GPU-accelerated nonlinear BMPC, the shared initial part of the tree is still the hardest part to parallelize, and better GPU methods are needed for trees with medium horizon lengths and multiple leaf nodes. A future CUDA C++ implementation is also expected to outperform current JAX-based prototypes (Bouzidi et al., 4 Feb 2025, Zhang et al., 16 Jun 2025).

Taken together, these developments define BMPC as a mature but still rapidly evolving family of methods: a tree-based MPC paradigm for multi-modal uncertainty, distinguished by structurally enforced non-anticipativity, conditional future adaptation, and an increasing reliance on scenario selection, risk-aware branching, and structure-exploiting numerical solvers.