Co-designing a Layered Control Architecture

arXiv:2610.20900 · math.OC, cs.SY, eess.SY · Submitted 2026-10-14 · Read on arXiv

Listen

Transcript

Introduction to the show: ident: Robotics Radio. Generated commentary on the latest robotics and control papers.

Rosa: Today's paper: "Co-designing a Layered Control Architecture".

Dev: The gist: This work presents a framework for co-designing a two-layer Layered Control Architecture (LCA) by optimizing over architectural and tuning-based design variables subject to stability, feasibility, and compute constraints.

Rosa: First, who's behind it and why it matters.

Paper summary: Dev: To summarize this paper, "Co-designing a Layered Control Architecture," they aim to get a better understanding of the fundamental relations in LCAs by testing these ideas on a simple, linear, two-layer example.

Taro: They are instantiating the co-design philosophy on a linear time-invariant plant defined by state space equations (one) and its discretized representation with sampling time tauL >Page three>.

Rosa: The core of the work is defining the design variables phi, which are the architectural choices like reduced order model dimension and sampling ratio between layers, as well as tuning-based variables theta, which are the numerical values for parameters like feedback gains or reduced order model matrices >Page two> <ref:2610.20900#pg3>.

Dev: The objective is to minimize a multi-valued cost function called cost(phi, theta) which maps these design choices onto Pareto curves representing tradeoffs in speed, accuracy, and compute effort >Page 18a>.

Taro: They enforce stability through the constraint ρ(A Nr cl − Π⊤x ApΠx) less than or equal to one >Page 18a>.

Rosa: And they enforce feasibility by requiring that there exists a set of Y and R, which is the set-valued function F(Y, R), such that (Y, R) is contained within Fphi,theta(Y, R) >Page two> <ref:2610.20900#pg3>.

Dev: They also have to satisfy the compute constraints we talked about earlier: TC(phi, theta) less than or equal to tauL and TP(phi, theta) less than or equal to Nr times tauL >Page nineteen>.

Taro: The analysis shows that closed-loop stability isn't guaranteed just by having individually stable C and P; there's a term Π⊤x(¯yn − y¯n+one) that can counteract compounding mismatch if the planner P is designed correctly >Page eight>.

Rosa: So, this paper provides an explicit formulation for finding the co-design problem as min phi, theta cost(phi, theta) subject to those stability and feasibility conditions >Page 18a>.

Dev: It's a concrete co-design problem that allows researchers to systematically navigate the space of LCA designs by looking at how speed relates to accuracy versus computational load >Page three>.

Taro: The numerical results show the feasible region on a grid defined by ny times Nr in the top-left plot, and they show Pareto curves illustrating tradeoffs toward maximizing accuracy or minimizing computation load >Page nineteen>.

Rosa: They find that an informed tradeoff between speed, accuracy, compute effort, and some diversity factor results in a 'consensus LCA' that balances everything well >Page nineteen>.

Dev: This paper is laying the groundwork for a theory because it presents a tractable starting point for co-designing LCAs >Page two> <ref:2610.20900#pg3>.

Conclusion: Taro: So, looking at the paper "Co-designing a Layered Control Architecture," what's the main implication of this work? It’s about moving away from designing these architectures based on experience.

Rosa: Exactly. The authors are providing a systematic framework to design them by jointly optimizing architecture and tuning variables under stability, feasibility, and compute constraints >Page one> <ref:2610.20900#pg3>.

Dev: It gives us a way to explicitly formulate the problem so we can map out the space of Pareto-optimal LCA designs based on speed versus accuracy or computation >Page nineteen>.

Taro: What this means for autonomy is that we move toward creating systems where you don't just hope they work, but you have a method to generate systems that are guaranteed to be stable and runnable in real-time >Page 18a>.

Rosa: It’s about making the design process more rigorous by forcing us to consider all those factors at once, not just one aspect at a time >Page one> <ref:2610.20900#pg3>.

Dev: The authors used a simple linear, two-layer plant to create this tractable starting point for understanding fundamental relations in LCAs >Page two> <ref:2610.20900#pg3>.

Taro: So the work is about providing a concrete starting point for systematic design by showing how these different components interact mathematically >Page two> <ref:2610.20900#pg3>.

Rosa: It’s about taking something that's mostly designed ad hoc and giving us a method to systematically reason about stability, feasibility, and performance >Page one> <ref:2610.20900#pg3>.

Chris Verhoek, Charis Stamouli, George J. Pappas, Nikolai Matni

University of Pennsylvania · Eindhoven University of Technology · ETH Zurich

math.OC, cs.SY, eess.SY

Submitted: 2026-10-14

Updated: 2026-10-14

Comments: 19 pages, extended version

License: http://creativecommons.org/licenses/by-nc-sa/4.0/

Importance score: 77/100

The gist: The gist: This work presents a framework for co-designing a two-layer Layered Control Architecture (LCA) by optimizing over architectural and tuning-based design variables subject to stability,

Key concepts

Layered Control Architecture (LCA): LCAs are complex control systems divided into multiple layers. The idea is to use different layers for different tasks—one layer might handle fast dynamics while another manages slower, more complex decisions. This structure helps manage complexity and improve system performance.
Co-design Problem: This is the core optimization task where architectural choices (like model size) and tuning parameters (like feedback gains) are optimized simultaneously. The objective is to minimize a cost function that balances competing goals, such as making the system fast while keeping it accurate and computationally cheap.
Stability Constraint: This constraint ensures that the interactions between the different control layers within the closed-loop LCA do not lead to instability. It guarantees that even with multiple layers working together, the overall system remains predictable and does not diverge over time.
Computational Feasibility Constraint: This constraint ensures that the resulting LCA can actually run in real-time on a computer. It limits the number of computations required per time step to be less than the available sampling times, guaranteeing that decisions are made fast enough for practical application.

Summary

The gist: This work presents a framework for co-designing a two-layer Layered Control Architecture (LCA) by optimizing over architectural and tuning-based design variables subject to stability, feasibility, and compute constraints.

Problem Formulation

The core problem is to optimize over the design variables ϕ and θ to find a set of LCA designs that are stable, feasible, and satisfy compute constraints <ref:2610.20900#pg19>. The formulation involves defining architecture-based design variables ϕ as the tuple of architectural choices such as ny, nr, Nr, τL, L <ref:2610.20900#pg6> and tuning-based design variables θ as the tuple of numerical values for parameters like K, Ap, Bp <ref:2610.20900#pg18>. The objective is to minimize a multi-valued cost function cost(ϕ, θ) which maps choices to Pareto curves representing tradeoffs in speed, accuracy, and compute.

Stability and Feasibility Constraints

The stability constraint (18b) ensures that the interactions between the layers in the closed-loop LCA are stable, which is directly derived from (10) <ref:2610.20900#pg9>. The constraint (18c) ensures that a particular choice of ϕ, θ results in a feasible LCA design: P and C must be such that by only actively enforcing (non-empty) constraints in P, xk ∈ X, uk ∈ U will be inherently satisfied by C <ref:2610.20900#pg19>.

Computational Feasibility Constraint

The constraint (18d) is a computational feasibility constraint, guaranteeing real-time implementation of the LCA: (¯yn, r¯n) and uk must be computed within the sampling times τH and τL, respectively <ref:2610.20900#pg19>. This is enforced by requiring TC(ϕ, θ) ≤ τL and TP(ϕ, θ) ≤ NrτL <ref:2610.20900#pg19>.

Analysis of Interactions

The analysis of interactions between the layers starts with characterizing the tracking error ein on the fast timescale (8a), which is then expressed as a summation involving A i cl and gn <ref:2610.20900#pg7>. The evolution on the slow timescale shows that closed-loop stability is not guaranteed by individually stable C and P <ref:2610.20900#pg8>. The term Π⊤x(¯yn − y¯n+1) can counteract compounding mismatch if P is designed such that the updated reference is exactly canceling SNr gn.

Construction of Constraint Sets

The set-valued function F(Y, R) returns the erosion of (X, U) for a given (Y, R). The constraint sets (Y, R) for the planner P that will guarantee constraint satisfaction of the LCA are the solution to the fixed point problem F(Y⋆, R⋆) = (Y⋆, R⋆). The anti-tone property of F in (Y, R) is proven under the condition ρ(A Nr cl − Π⊤x ApΠx) < 1.

Co-design Problem and Cost Definition

The co-design problem for the considered two-layer LCA is formulated as min ϕ,θ cost(ϕ, θ) (18a) s.t. ρ(A Nr cl − Π⊤x ApΠx) < 1, ∃(Y, R) ̸= (∅, ∅): (Y, R) ⊆ Fϕ,θ(Y, R), TC(ϕ, θ) ≤ τL, TP(ϕ, θ) ≤ NrτL. The cost function is defined as cost(ϕ, θ):= [Jspeed(ϕ,… Jaccuracy Jcompute(ϕ,θ)]⊤.

Numerical Results

The numerical results demonstrate the feasible region on the grid ny × Nr in the top-left plot. The Pareto curves show that tradeoffs made in the LCA designs either leaned toward maximizing accuracy (△), speed, minimizing computational load (□), or taking the diversity-enabled σ-sweet spot (⋆). An informed tradeoff between the three considered components in cost results in the lower-right response, which can be seen as the ‘consensus LCA’ that is sufficiently accurate and fast, while meeting the compute limitations.

Conclusion

The paper presents a first step toward systematic and holistic design of layered control architectures (LCAs) by jointly optimizing over architecture-based and tuning-based design variables subject to stability, feasibility, and compute constraints. This framework provides an explicit formulation to navigate the complex space of Pareto-optimal LCA designs.

References

M. Alharbi, M. A. Dahleh, and G. Zardini, Compositional online learning for multi-objective system co-design A. Censi, A mathematical theory of co-design N. Csomay-Shanklin, A. J. Taylor, U Rosolia, and A D Ames, Multi-rate planning and control of uncertain nonlinear systems: Model predictive control and control Lyapunov functions B. A Davey and H. A Priestley, Introduction to lattices and order G. Ellis, Control system design guide G E Fainekos, A Girard, H Kress-Gazit, and G J Pappas, Temporal logic motion planning for dynamic robots A Girard and G J Pappas, Hierarchical control using approximate simulation relations A Girard and G J Pappas, Hierarchical control system design using approximate simulation S L Herbert, M Chen, S Han, S Bansal, J F Fisac, and C J Tomlin, Fastrack: A modular framework for fast and guaranteed safe motion planning M Herceg, M Kvasnica, C Jones, and M Morari. Multi-Parametric Toolbox 3.

Improvements for AI systems

Bold header: Systematic LCA Co-design Framework

The improved AI system can perform joint optimization over architectural design variables (e.g., reduced order model dimension and sampling ratio) and tuning-based design variables (e.g., the numerical values of the feedback gain or the matrices of the reduced order model). This allows for a systematic exploration of Pareto-optimal designs across axes like speed, accuracy or computational effort by minimizing a multi-objective cost function.

Bold header: Guaranteed Stability and Feasibility

The system can ensure that any candidate LCA design is stable and feasible by satisfying the derived stability condition: a ϕ, θ-dependent stability condition, which is guaranteed if the resulting set of planning constraints satisfies (18c): ∃ (Y, R) ≠ (∅, ∅): (Y, R) ⊆ Fϕ,θ(Y, R).

Bold header: Real-Time Implementation Guarantee

The improved AI system can guarantee online implementability by ensuring the computational complexity constraints are met via the constraint (18d): TC(ϕ, θ) ≤ τL and TP(ϕ, θ) ≤ NrτL, which ensures that the reference computed by P in the interval [n + 1, n + 2] can only be tracked by C in the interval [n + 2, n + 3] within required time bounds.

Bold header: Constraint Satisfaction via Set-Valued Maps

The system can determine if a design is feasible by utilizing the anti-tone property of the constraint set map F, which allows for the construction of a set-valued function that returns the erosion of (X, U) for a given (Y, R) and solving (16) F(Y⋆, R⋆) = (Y⋆, R⋆) to find constraint sets that guarantee constraint satisfaction of the LCA.

Bold header: Informed Tradeoff Navigation

The system enables informed tradeoffs by mapping design choices to Pareto curves using the cost function: cost(ϕ, θ):= [Jspeed(ϕ,θ) Jaccuracy(ϕ,theta) Jcompute(ϕ,theta)]⊤, allowing designers to select a specific LCA design based on specified priorities like minimizing computation or maximizing accuracy.

Abstract

Layered control architectures (LCAs) are ubiquitous in complex engineering systems. However, in practice they are largely designed ad hoc and mostly dictated by the experience of the designer. This is because there is currently no systematic and practically applicable theory available to holistically design LCAs. Hence, systematically reasoning about the optimality, stability, and feasibility of the LCA design is not possible. We set a first step toward such a theory by presenting a framework for co-designing a two-layer LCA for a linear time-invariant plant. The resulting co-design problem optimizes over architectural design variables (e.g., reduced order model dimension and sampling ratio between the layers) and tuning-based design variables (e.g., the numerical values of the feedback gain or the matrices of the reduced order model), all subject to constraints that ensure stability, feasibility, and compute properties of the closed-loop LCA. The proposed formulation allows to make informed tradeoffs along the Pareto front traced over different axes of optimality, e.g., speed, accuracy or computational effort. We demonstrate the effect of making various tradeoffs in a simple numerical example.