💻 computer science

Towards Safe Path Tracking Using the Simplex Architecture

This paper proposes a path-tracking controller based on the Simplex architecture that integrates a high-performance Reinforcement Learning controller with a high-assurance safety controller to ensure stable and safe robot navigation in complex environments.

Original authors: Georg Jäger, Nils-Jonathan Friedrich, Hauke Petersen, Benjamin Noack

Published 2026-02-12

📖 4 min read☕ Coffee break read

CC0 1.0

Original authors: Georg Jäger, Nils-Jonathan Friedrich, Hauke Petersen, Benjamin Noack

Original paper dedicated to the public domain under CC0 1.0 (http://creativecommons.org/publicdomain/zero/1.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are teaching a teenager how to drive a car.

You want them to be a great driver—fast, smooth, and able to handle tricky turns or sudden rain (this is the "High-Performance" part). However, teenagers are unpredictable. They might get distracted, take a corner too fast, or make a mistake that could lead to a crash.

To keep them safe, you don't just give them the keys and walk away. Instead, you sit in the passenger seat with a "Safety Override" button. As long as they are driving well, you stay quiet. But the moment you see them drifting toward the curb or approaching a turn too aggressively, you grab the wheel or hit the brakes to bring the car back to safety (this is the "High-Assurance" part).

This paper describes exactly that system, but for robots.

The Problem: The "Genius vs. Safety" Dilemma

In the world of robotics, there is a tug-of-war between two types of "brains":

The "Genius" Brain (Reinforcement Learning): These are AI controllers that learn by trial and error. They are incredibly adaptable and can navigate complex paths better than almost anything else. The catch? They are "black boxes." Even the creators can't always predict exactly what the AI will do in a weird, unexpected situation. It’s brilliant, but it’s a gamble.
The "Rule-Follower" Brain (Traditional Controllers): These are old-school mathematical formulas. They aren't very "smart" or adaptable, but they are incredibly predictable. You know exactly how they will react every single time. They are safe, but they are often slow and clunky.

If you use the Genius, the robot might crash. If you use the Rule-Follower, the robot might be too slow to be useful.

The Solution: The "Simplex Architecture"

The researchers used a concept called the Simplex Architecture. Think of it as a Safety Envelope.

They wrapped the "Genius" AI inside a protective bubble created by the "Rule-Follower." They added a third component: a Decision Module (the "Judge").

The Genius tries to drive the robot along a path as efficiently as possible.
The Judge constantly watches the robot’s position. It doesn't just look at where the robot is; it uses math to predict where the robot will be in the next split second.
The Switch: If the Judge predicts that the Genius is about to drive the robot outside of a "safe zone" (like getting too close to an obstacle or losing control), it instantly kicks the Genius out and hands the controls to the Rule-Follower.
The Return: Once the Rule-Follower has stabilized the robot and brought it back to a safe, steady state, the Judge allows the Genius to take the wheel again.

What did they find?

The researchers tested this on a mobile delivery robot (like the ones you might see on a sidewalk).

It works! When they used a "suboptimal" AI (one that was intentionally poorly trained to act erratically), the Simplex system caught the mistakes and prevented the robot from veering off course.
The Trade-off: There is a small "tax" on performance. Because the safety system is cautious, it sometimes switches to the "Rule-Follower" a little earlier than strictly necessary. This makes the robot slightly slower, but it ensures the robot stays on the path.

The Big Picture

This paper provides a blueprint for how we can use powerful, unpredictable AI in the real world—in delivery robots, farm equipment, or even self-driving cars—without having to worry that a "brain fart" from the AI will result in a disaster. It allows us to enjoy the brilliance of AI while keeping the reliability of traditional math as our safety net.

Technical Summary: Towards Safe Path Tracking Using the Simplex Architecture

1. Problem Statement

Autonomous mobile robots require path-tracking controllers that are simultaneously performant (adaptable to complex, dynamic environments) and safe (providing formal guarantees of stability and collision avoidance).

The Dilemma: Traditional geometric or model-predictive controllers (e.g., Pure Pursuit, MPPI) offer stability but struggle with adaptivity. Conversely, Reinforcement Learning (RL) offers high performance and adaptability but operates as a "black box," making it nearly impossible to provide state-wise safety or stability guarantees.
The Gap: There is a lack of hybrid architectures in existing frameworks (like ROS2) that can bridge this gap by wrapping uncertified, high-performance controllers within a safety envelope.

2. Methodology

The authors propose a path-tracking controller based on the Simplex Architecture, which utilizes a "separation of concerns" approach. The system consists of three core components:

High-Performance Controller ( $C_p$ ): An RL-based controller trained using the TD3+BC (Twin Delayed Deep Deterministic Policy Gradient with Behavioral Cloning) algorithm. It is designed to optimize performance and adapt to complex trajectories.
High-Assurance Controller ( $C_a$ ): A traditional Regulated Pure Pursuit (RPP) controller. It is designed to be inherently stable and safe, even if its performance is suboptimal.
Decision Module ( $D$ ): A switching mechanism that monitors the system state. It switches from $C_p$ to $C_a$ if the system approaches an unsafe state, and switches back to $C_p$ only after the system has stabilized.

Technical Implementation Details:

Stability & Safety Analysis: The authors use simulation-based reachability analysis to determine the Region of Attraction (RoA) of the high-assurance controller. This defines the set of states from which the robot is guaranteed to return to the path.
Switching Strategy: The decision module uses a restricted safe operating space ( $X'_{S|C}$ ), which is the intersection of the RoA and the safety requirements (e.g., staying within 1m of the path). To prevent instability caused by rapid switching, the authors implement a Dwell Time ( $T_d$ )—a minimum duration the robot must remain under the high-assurance controller before switching back to RL.

3. Key Contributions

Design Framework: A formal discussion and methodology for designing Simplex-based controllers, specifically focusing on how to derive switching strategies using RoA, safety constraints, and dwell time to ensure stability in switched systems.
Simplex Path-Tracking Controller: The implementation of a practical, ROS2-compatible architecture that wraps an RL agent with a high-assurance geometric controller.
Empirical Validation: A comprehensive evaluation involving both high-fidelity Gazebo simulations and real-world deployment on a Clearpath Husky robot.

4. Results

The performance was evaluated on two tracks: a curved track ( $P_{cos}$ ) and a squared track ( $P_{square}$ ) with sharp turns.

Safety Assurance: The Simplex controller ( $\hat{C}_S$ ) successfully prevented safety violations even when using a "suboptimal" (prematurely trained) RL controller. While the standalone suboptimal RL controller failed significantly (deviating up to 2.75m from the path), the Simplex architecture kept deviations within the 1m safety limit.
Performance vs. Safety:
- On the curved track, the Simplex controller achieved performance comparable to state-of-the-art methods (like MPPI), as the decision module rarely needed to trigger the fallback.
- On the squared track, the decision module frequently triggered the high-assurance controller to handle sharp turns. This maintained safety but resulted in a lower average velocity compared to pure RL.
Comparison: While the DWB controller showed lower error, it had very low velocity. The Simplex controller provided a superior balance of high velocity (when safe) and guaranteed safety (when challenged).

5. Significance

This work provides a blueprint for the safe deployment of machine learning in robotics. By demonstrating that high-performance, uncertified algorithms (like RL) can be used in safety-critical applications if wrapped in a Simplex architecture, the authors address a major barrier to the widespread adoption of autonomous mobile robots in public spaces (e.g., sidewalk delivery). The paper highlights that while current implementations may be conservative (limiting performance to ensure safety), the architecture provides a mathematically grounded path toward combining AI adaptability with classical control reliability.