Hierarchical and Layered MPC Architectures

• Hierarchical and layered MPC architectures are control frameworks that decompose complex tasks into multiple time-scaled layers with distinct roles.
• They use upper layers for long-horizon planning with reduced models and lower layers for fast, high-fidelity control to ensure feasibility and safety.
• Applications span robotics, energy management, and autonomous navigation, providing modular design, confidentiality, and computational efficiency.

A hierarchical or layered Model Predictive Control (MPC) architecture is a structured control strategy that decomposes complex control objectives across multiple time scales, abstraction levels, or decision granularity. Such architectures are essential for handling high-dimensional, nonlinear, or hybrid systems where direct monolithic MPC is computationally prohibitive or too inflexible for modular design. In these multilayer schemes, upper layers typically generate long-horizon reference trajectories, targets, or contracts, while lower layers refine and enforce these via fast, high-fidelity controllers—often with mechanisms to ensure feasibility, safety, and modularity even under model uncertainty or partial layer knowledge.

1. Core Principles of Hierarchical and Layered MPC

Hierarchical MPC decomposes control optimization according to temporal resolution, model fidelity, or task abstraction. The foundational paradigm leverages the following:

• Temporal Decoupling: Upper (slow) layers solve larger-horizon, coarse-sampled MPC using approximate or reduced-order models to provide references or constraints to lower (fast) layers, which in turn solve smaller-horizon, fine-sampled MPC on full-fidelity models (Farina et al., 2017, Benders et al., 17 Jun 2024).
• Information Exchange: Coordination is achieved via setpoints, reference trajectories, contracts, or certificates passed top-down, and feasibility or tracking quality propagated bottom-up. Layer separation may be enforced through minimal required interfaces, e.g., explicit feasibility value functions or tube sets.
• Model Abstraction and Decomposition: High-level planners may employ reduced-order, linearized, or otherwise abstracted models, while low-level controllers operate on the true nonlinear or hybrid dynamics, leveraging recent advances in robust MPC and error compensation (Schmitt et al., 2023, Berkel et al., 16 Apr 2025).

This organization allows for modular controller synthesis, distributed design, and scalable implementation—crucial in embedded, networked, or IP-sensitive settings.

2. Contract and Certificate Based Layer Coupling

Rigorous hierarchical MPC architectures require guarantees that high-level references can be executed by the low-level controllers without violation of constraints, independence of layer-specific details, and real-time feasibility of online operation. Two dominant approaches are:

• Predictive Feasibility Value Functions ("Contract-based" MPC): The lower-level controller solves a soft-constrained MPC to track high-level references subject to strict physical constraints, where the magnitude of optimal slack variables quantifies how well the reference can be obeyed. This scalar "contract" (the minimal aggregated constraint violation) is provided to the high-level planner as a value function $h^*(x, r^H)$—zero if the reference is feasible, positive otherwise. The planner augments its cost with this contract, ensuring that only feasible references are passed down. Crucially, $h^*(x, r^H)$ is replaced by a neural network or lookup-table surrogate $h_C(x, r^H)$, preserving model confidentiality and elevating computational tractability (Berkel et al., 16 Apr 2025).
• Bezier Reachable Polytopes (BRPs): For systems where trajectory tracking can be reducible to planning in a space of feasible Bezier-polynomial trajectories, the set of admissible endpoint connections can be precomputed as convex polytopes. The high-level planner is then restricted to choosing only those waypoints for which the corresponding Bezier curve is certifiably trackable by the lower-level controller while satisfying all constraints—both input and state—by design (Csomay-Shanklin et al., 20 Nov 2024).

These methods provide mathematically sharp feasibility certificates and compartmentalize the knowledge required for each layer, a key for modular and IP-protecting engineering practices.

3. Tube-Based and Recursive Feasibility Mechanisms

Ensuring recursive feasibility and stability across layers is nontrivial; it typically involves tube-based formulations or stage-wise constraint tightening:

• Tube-Based Hierarchical MPC: Upper layers generate reference trajectories and an associated invariant "tube" set (error bound) within which the lower-layer trajectories are required to stay. Tubes, which may be optimized online as zonotopes, encode both inter-layer model mismatch and coupling uncertainty. By enforcing stage-wise constraint inclusions and explicit tightened terminal ingredients, this approach rigorously guarantees recursive feasibility for all subsystems and arbitrary lower-layer controller architectures (Raghuraman et al., 2022, Surmaa et al., 14 Jul 2025).
• Adjustable Tube and Set Tightening: Rather than employing fixed tube sizes, modern architectures permit online optimization of tube sizes as auxiliary decision variables in the upper-layer MPC, balancing feasibility, performance, and inter-layer flexibility (Raghuraman et al., 2022). Tightened state and input sets are constructed through Pontryagin differences to absorb disturbances, model reduction error, or uncertainties in lower-level execution (Farina et al., 2017, Amini et al., 2019).
• Parent-Child MPC Structures: In such settings, a large-horizon, possibly linear parent (P-MPC) computes tubes or robust invariant sets, while child (C-MPC) controllers solve small-horizon, high-fidelity MPC problems subject to stagewise tube inclusions—thereby avoiding over-conservative terminal constraints, minimizing requisite online computation, and rigorously certifying recursive feasibility (Surmaa et al., 14 Jul 2025).

4. Architectural Patterns and Application Examples

The breadth of hierarchical/layered MPC is evidenced across disparate domains and system classes:

Scenario	Upper Layer Details	Lower Layer Role
Contract-based motion planning (Berkel et al., 16 Apr 2025)	Planner with soft constraint contract surrogate	Nonlinear MPC, constraint slack value
BRP-guided robotics (Csomay-Shanklin et al., 20 Nov 2024)	Task planning in BRP-constrained waypoint graph	Tracking feedback law via Bezier reference
Energy management (Schmitt et al., 2023)	Aggregator: building-level, error-compensated MPC	Zone-level MPC with regression error compensation
Nonlinear hybrid systems (Olkin et al., 17 Mar 2025)	High-level: domain/guard sequence on slow timescale	Low-level: fixed-mode robust tube MPC
Quadrotor navigation (Benders et al., 17 Jun 2024)	Planner: long-horizon, slow nonlinear MPC	Fast tracking MPC with offline tightening
Task-space robots (Lee et al., 2020)	Finite-horizon anticipative MPC for task errors	Hierarchical QCQP encoding for task priorities

In each, layer responsibilities are apportioned according to system time scales, planning horizon, reference abstraction, or operating constraints, with constraints on the upper layer chosen so as to guarantee feasible tracking/enforcement by the lower layer under all modeled uncertainty.

5. Modular Design, Confidentiality, and Computational Efficiency

Hierarchical architectures specifically support:

• Modular and Confidential Layer Development: Explicit value functions and contract surrogates (e.g., $h_C(x, r^H)$) allow lower layers to hide detailed dynamics, constraint sets, and cost structures from the upper layer. The upper layer only requires access to the surrogate contract for its optimization, and not to details of the lower-layer model or constraints (Berkel et al., 16 Apr 2025).
• Scalable Computation: Decoupling planning and tracking allows long-horizon, slow-sampled high-level controllers to offload short-horizon, high-rate control refinement to lower layers, reducing the dimensionality and frequency of high-order nonlinear or hybrid MPC optimization. Real-time feasibility is achieved even under embedded or resource-constrained execution, evidenced by order-of-magnitude reductions in online computation versus monolithic MPC (Csomay-Shanklin et al., 20 Nov 2024, Benders et al., 17 Jun 2024).
• Robustness against Model Mismatch: Regression-based error compensation at multiple levels (Schmitt et al., 2023), tube-based disturbance absorption (Raghuraman et al., 2022), and adaptive constraint tightening (Amini et al., 2019) confer robustness to modeling errors, forecast noise, and environmental uncertainty.

6. Theoretical Guarantees and Performance Analysis

Hierarchical and layered MPC schemes are underpinned by theoretical results establishing feasibility, safety, and stability:

• Recursive Feasibility and Constraint Satisfaction: Provided the contract or tube constraints are appropriately chosen and strictly enforced, both upper and lower layers preserve recursive feasibility, ensuring input and state constraints are never violated, even under disturbances, interconnection couplings, or neural-network approximation error in contract functions (Berkel et al., 16 Apr 2025, Raghuraman et al., 2022, Benders et al., 17 Jun 2024).
• Stability: Stability results include robust invariance of error sets in tube-based approaches, Lyapunov stability for hybrid systems (using domain/guard logic at the high-level), and asymptotic convergence to goal sets under baseline policies in Markovian decision-making settings (Olkin et al., 17 Mar 2025, Wang et al., 12 Jan 2024).
• Optimality and Sample Efficiency: In learning-assisted or sample-averaging hierarchies, long-run closed-loop performance approaches that of a centralized optimal controller under ergodicity and sample-average convergence frameworks (Kumar et al., 2018, Studt et al., 19 Sep 2025).

Empirical evidence across energy management, autonomous navigation, robotics, and automotive benchmarks confirms high tracking accuracy, constraint satisfaction, and computational gains compared to centralized or monolithic MPC.

7. Extensions, Limitations, and Future Directions

• Architectural Extensions: Hierarchical MPC frameworks are extendable beyond two layers, with multilevel tube structures or nested contracts supporting further decomposition in very large-scale or distributed systems (Raghuraman et al., 2022).
• Adaptive and Learning-Integrated Hierarchies: Recent works have embedded data-driven surrogates, reinforcement learning, or regression-based compensators into one or more layers, combining sample efficiency of learning with real-time feasibility guarantees of model-based control (Schmitt et al., 2023, Studt et al., 19 Sep 2025).
• Trade-offs and Tuning: Size of tubes, contract function margins, sampling periods, model abstraction fidelity, and interlayer interface selection trade off performance, feasibility region tightness, and computational effort—a critical area for systematic tuning.
• Open Challenges: Limitations include potential conservatism due to abstraction and tightening, difficulty in extending formal guarantees to deeply nonconvex, coupled, or highly nonlinear systems, and complexity in interface definition for arbitrary networked topologies.

Overall, hierarchical and layered MPC architectures represent a rigorous, scalable, and modular class of control frameworks, supporting real-time closed-loop safety and performance in complex, high-dimensional, and networked cyber-physical systems (Berkel et al., 16 Apr 2025, Csomay-Shanklin et al., 20 Nov 2024, Raghuraman et al., 2022, Surmaa et al., 14 Jul 2025, Benders et al., 17 Jun 2024).