Model Predictive Control (MPC) Architecture

• MPC architecture is a structured framework that leverages system models to predict and optimize future control actions over a moving horizon with constraints.
• It integrates hierarchical designs, explicit piecewise affine controllers, and learning-based models to address scalability, uncertainty, and real-time demands.
• Co-design strategies and robust tube-based methods ensure safety, computational efficiency, and adaptability for complex, distributed, and nonlinear systems.

Model Predictive Control (MPC) architectures are structured frameworks for synthesizing constrained optimal controllers that exploit system models to forecast and optimize future behavior over a moving time horizon. The breadth of MPC architectures encompasses hierarchical designs for large-scale systems, hardware-software co-design, explicit and operator-theoretic reformulations, and learning-integrated frameworks. These architectures are distinguished by their mathematical rigor, model-coupling strategies, real-time implementability, and capacity to address scalability, uncertainty, and application-specific demands.

1. Hierarchical and Layered MPC Architectures

Hierarchical MPC architectures decompose control of large-scale or interconnected systems into multiple, interacting layers, each operating at different temporal or spatial resolutions.

High-Level (Centralized) MPC Layer:

A reduced-order, low-frequency model is used for strategic or long-term global optimization. This layer plans on a slow timescale, optimizing an objective such as

$$\min_{\bar{x}^{[N_L],o}(t),\, \bar{u}^{[N_L],o}(t:t+N_H-1)} J_{\mathrm{H}}\left( \bar{x}^{[N_L],o}(t), \left\{ \bar{u}^{[N_L],o}(t:t+N_H-1) \right\} \right)$$

subject to reduced-order dynamics, disturbance modeling (e.g., tube-based robustness), and tightened constraints incorporating state-reset via projection operators (e.g., $\bar{x}^{[N_L]}(k) = \beta x(kN_L)$) (Farina et al., 2017).

Low-Level (Decentralized) Local Regulators:

Full-order subsystem models running at higher frequency track and refine actions dictated by the high-level layer. Each local regulator solves finite-horizon optimal control problems with initial/terminal constraints that couple the local subsystem's state to the high-level trajectory, correcting model mismatches and local disturbances through feedback and auxiliary simulation models. Local optimization problems are of the form: $$\min_{\delta\hat{u}_i(h)} \sum_{j=0}^{N_L-1} \left( \|\delta\hat{x}_i(kN_L+j)\|_{Q_i}^2 + \|\delta\hat{u}_i(kN_L+j)\|_{R_i}^2 \right)$$ with terminal constraints to enforce alignment with the projected high-level evolution.

Closed-Loop Integration:

Control actions are formed by additive combination of the high-level policy and local corrections,

$$u_i(h) = \bar{u}_i^{[N_L]}(\lfloor h/N_L \rfloor) + \delta u_i(h)$$

Realized trajectories thus encapsulate long-term optimality and local compensation (Farina et al., 2017).

Layered Nonlinear Control for Hybrid Systems:

Extensions for nonlinear hybrid systems utilize a high-level "hybrid" MPC to plan domain/guard sequences and a low-level fixed-mode MPC for rapid continuous optimization, with robustness achieved via tracking error tubes and receding horizon recalculation tied to tube growth (Olkin et al., 17 Mar 2025).

2. Explicit MPC and Function Approximation Architectures

Explicit MPC formulations precompute the mapping from state to optimal control input, either as explicit piecewise affine functions or using data-driven function approximators, avoiding online optimization at runtime.

Explicit Piecewise Affine Controllers:

For linear, constrained systems, the MPC law is continuous piecewise linear (CPWL), representable as a partition of the state/reference space with affine control laws per region (Ferlez et al., 2019). Lattice representations provide

$$f(x) = \max_{1 \le i \le M} \min_{j \in s_i} \ell_j(x)$$

AReN (Ferlez et al., 2019) develops algorithms to determine minimal ReLU NN architectures capable of exactly reproducing a given CPWL MPC controller by estimating the number and structure of affine regions.

Manifold Learning for Explicit MPC:

To address curse-of-dimensionality, manifold learning approaches (e.g., diffusion maps with control-informed similarity metrics) are used to discover lower-dimensional representations of the MPC policy manifold. Function approximation methods (polynomial regression, ANNs, Gaussian processes with Matérn kernels) are trained to map between state (or augmented state/reference) space and the control policy, enabling fast explicit controllers particularly when the intrinsic dimension of the policy is low (Lovelett et al., 2018).

Operator Neural Network MPC:

DeepONet and MS-DeepONet architectures utilize neural operators to model the full input–output mappings over multi-step horizons for nonlinear dynamical systems. MS-DeepONet encodes control sequences and initial conditions into compact representations allowing one-shot prediction of entire future output trajectories, theoretically guaranteed by universal approximation results (Jong et al., 23 May 2025). Automated architecture search and PyTorch-based implementation facilitate integration into closed-loop MPC for systems including van der Pol, quadruple tanks, and pendulum-on-cart benchmarks.

3. Hardware-Software Co-Design and Real-Time Considerations

MPC architectures increasingly integrate computational awareness into controller synthesis.

Bi-Objective Co-Design Frameworks:

Design automation involves simultaneous tuning of controller software parameters (e.g., horizon length, sampling interval, Q/R penalties) and hardware platform variables (e.g., number of fixed-point fractional bits on FPGA). The multi-objective optimization leverages algorithms such as BiMADS to obtain Pareto optimality across control performance (e.g., closed-loop settling time) and computational resource metrics (e.g., CPU execution time, FPGA silicon metrics) (Khusainov et al., 2017). Derived controllers outperform Latin Hypercube Sampling-based and manual tuning approaches in both performance and resource efficiency.

Adaptive Regression MPC:

Adaptive regression-based architectures use machine learning models (e.g., support vector regressors trained on synthetically generated features such as curvature, wavelet coefficients, and tracking error) to predict, per control cycle, the minimum sufficient horizon and sample count required in the on-line MPC optimization. This adaptivity yields 35–65% computational time reduction relative to fixed-parameter schemes without discernible performance loss across linear and nonlinear benchmarks (Mostafa et al., 2022).

Triggering and Event-Based Architecture:

To optimize resource usage in embedded and battery-powered applications, architectures may use event-triggered recomputation policies for the computationally expensive MPC, with compensation by low-cost LQR controllers between updates. The timing policy is learned via reinforcement learning (e.g., policy gradient), trading off control objective with computational/energy cost, and is instantiated as a logistic regression over augmented state variables (Bøhn et al., 2020).

4. Uncertainty, Safety, and Robustness in MPC Architectures

Robustness to modeling error, disturbances, and the ability to guarantee safety and feasibility are central architectural concerns.

Tube-Based Robust MPC:

Layers of tube-based robust MPC use reduced-order models to plan with modeled disturbances (e.g., via disturbance sets $\mathcal{W}$), state resets, and terminal invariance constraints (Lyapunov-based), ensuring the planned high-level trajectory is feasible under model mismatch while allowing local controllers to compensate for errors at finer timescales (Farina et al., 2017).

Parent-Child MPC Without Terminal Constraints:

Recursive feasibility and closed-loop stability are obtained without conservative terminal constraints by coupling a long-horizon parent MPC, using linear tube-based tightening, with a short-horizon child MPC constrained to remain inside the parent-generated tube. The cross-section of the tube is a robust positive invariant set $E$, with interaction via Minkowski-theoretic constraint formulations. The architecture systematically enables larger controllable sets and computational efficiency while maintaining robustness for nonlinear systems (Surmaa et al., 14 Jul 2025).

Explicit Performance-Oriented Model Learning:

Data-driven identification for control (I4C) architectures employ Bayesian optimization (acquisition functions based on GP surrogates) to tune prediction models for closed-loop performance rather than prediction accuracy. Hierarchical structures allow fast inner controllers with outer MPC layers optimized via closed-loop experimental feedback to deliver robustness without conservative worst-case design (Piga et al., 2019).

Supervisory Safety Architectures:

Safe control architecture (SCA) deployments employ a supervisory MPC that certifies, via predictive constraint satisfaction, the safety of an operating controller's proposed inputs, activating backup schemes (e.g., degraded control, safe state transfer) if the predictive optimization is rendered infeasible. Model mismatch is handled via additive model uncertainty terms and enlarged constraints obtained by projecting empirically measured uncertainty sets, achieving conservative safety even under modeling errors (Nezami et al., 2022).

5. Distributed, Multi-Agent, and Nontraditional MPC Formulations

Emergent MPC architectures are tailored for distributed, multi-agent, or large-scale coordination.

Hierarchical Multi-Agent Integration:

Hybrid architectures such as Model Predictive Fuzzy Control (MPFC) delegate fast, local path-planning and action selection to distributed fuzzy logic controllers (FLCs), while a centralized MPC layer infrequently retunes local FLC parameters to optimize a global objective over a finite horizon. The global optimization variables are the FLC tuning variables, reducing the computational burden compared to fully centralized MPC (Maxwell et al., 6 May 2025).

Multi-Forecast and Stochastic MPC:

Incremental proximal multi-forecast architectures (IP-MPC) optimize over multiple scenario forecasts, coupling plans via a non-anticipativity constraint on the initial action. The coupled multi-scenario problem is solved by iteratively solving standard (single-forecast) MPC problems, augmented by a proximal quadratic term, which enables robust hedging against forecast uncertainty with only a modest increase in computational effort (Shen et al., 2021).

Category-Theoretic Modular Formulation:

Category-theoretic architectures formalize MPC as a composition of convex bifunctions (convex cost/constraint encodings) in a symmetric monoidal category, allowing modular, high-level string-diagrammatic construction of multistage and parallel constraint structures. The Para(Conv) formalism facilitates software realization (e.g., in Julia with Catlab.jl and Convex.jl), robustly supporting the sequential and parallel aggregation of constraints across stages, and promises enhanced correctness and maintainability for large and structured systems (Hanks et al., 2023).

6. Learning-Augmented and Foundation Model-Guided MPC

Integration with modern machine learning and foundation models is accelerating the expansion of MPC architectural concepts.

DNN-Embedded Process Models:

MPC may incorporate deep neural network-based surrogate plant models (e.g., LSTM and fully connected architectures) trained on large datasets to capture nonlinear process dynamics. Real-time optimization with such embedded models is achieved with custom NMPC software (e.g., acados), hardware acceleration, and communication infrastructure for experimental deployment. This allows the controller to achieve high-fidelity tracking under real-process uncertainty (e.g., <0.133 bar RMSE for HCCI engine control tasks), with sub-millisecond solve times suitable for embedded platforms (Gordon et al., 2023).

Vision-LLM (VLM) and Large Vision-LLM (LVLM) Guided MPC:

VLM-MPC and LVLM-MPC architectures feature a two-layer, asynchronous structure in which a foundation model (VLM or LVLM) processes real-time visual and scenario memory inputs to generate key driving parameters or symbolic commands. These parameters are used by an underlying MPC controller with detailed plant and constraint models to optimize trajectories, handle nonlinear engine lag, or build task-specific OCPs. Safety and feasibility feedback from the MPC to the VLM/LVLM supports adaptive planning and smooth task switching, guaranteeing constraint satisfaction and robust autonomous driving even under task changes or environmental variations (Long et al., 9 Aug 2024, Atsuta et al., 8 May 2025).

Learning-Friendly Soft MPC Integration:

Plug-and-play architectures such as MPCritic treat the parameterized MPC loss as a differentiable surrogate for RL training, embedding the MPC model, cost, constraints, and an approximate minimizer (“fictitious controller”) in the critic. This enables batched, gradient-based learning, and direct transfer of the trained parameters into an online MPC agent with robust constraint enforcement. The approach supports both linear–quadratic and nonlinear systems, as well as integration with actor–critic and entropy-regularized RL algorithms (Lawrence et al., 1 Apr 2025).

7. Applications, Scalability, and Comparative Assessments

Performance-Resource Tradeoffs:

Real-time embedded and cyber-physical systems (automotive, building climate, microgrids, robotics, disaster response) benefit from architectures that balance computational load—by delegating computation to slow, global or cloud-based MPC layers and fast, local real-time controllers—and from careful integration of forecasts, scenario memory, or symbolic reasoning.

Comparative Efficacy:

Empirical results across diverse applications (building thermal systems, microgrids, pendulum stabilization, bipedal robotics, HCCI engine control, and autonomous driving) consistently demonstrate that advanced MPC architectures can yield improved performance, constraint satisfaction, safety, and real-time feasibility compared to both classical “monolithic” MPC and pure heuristic controllers, sometimes at dramatically reduced computational costs (Farina et al., 2017, Yi et al., 2018, Gordon et al., 2023, Maxwell et al., 6 May 2025, Surmaa et al., 14 Jul 2025).

Scalability:

Architectures based on compositional, hierarchical, or learning-compatible MPC formulations (e.g., multi-agent MPFC, parent-child tube-based, category-theoretic Para(Conv), function-approximator-based MPC) are particularly suited to problems with high dimensionality, distributed actuation, multiple uncertainty sources, and adaptive or informative planning layers.

---

In conclusion, the architecture of MPC is characterized by modular design philosophies—hierarchical decomposition, explicit and learning-based policy representations, robust tube-based feasibility assurances, hardware/software co-design, and integration with high-level perception and planning modules. These architectures enable scalable, safe, and efficient deployment of predictive controllers in complex, uncertain, and resource-constrained real-world applications. The state of the art continuously evolves through synthesis of rigorous mathematical principles, computational advances, and integration with data-driven and foundation model-based methodologies.