⚡ electrical engineering

Adaptive Nonlinear Control with Online Identification and Receding-Horizon Optimization

This paper presents AMIGO, an adaptive nonlinear optimal-control framework that integrates online parameter identification, receding-horizon iLQR planning, and closed-loop control with actuator constraints, validated through simulations of a Van der Pol oscillator, a quadcopter, and an autonomous lunar lander.

Original authors: Igor Ladnik

Published 2026-08-20

📖 8 min read🧠 Deep dive

CC BY 4.0

Original authors: Igor Ladnik

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.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

Controlling a machine that moves through the physical world is a constant negotiation between what the machine is supposed to do and what it actually does. In the ideal world of engineering textbooks, a robot's behavior is perfectly predictable: you give it a command, and it moves exactly as the math says it will. But in reality, machines are messy. Their parts wear down, their weight changes as they burn fuel, and the air they push against behaves in ways that are hard to pin down. Furthermore, the sensors that tell a robot where it is are never perfect; they are always slightly noisy. The central challenge for engineers is to build a control system that can handle this messiness in real time. It must figure out the true nature of the machine while it is moving, predict where it will go next, and adjust its commands instantly to stay on course, all without waiting for a human to intervene or for the machine to stop.

This is the problem addressed by a new approach called AMIGO, developed by researcher Igor Ladnik. The system is designed to guide complex machines, such as drones or spacecraft, by combining three distinct activities that happen in a specific order. First, the system listens to the machine to learn its true characteristics. Second, it uses that new knowledge to map out a long-term path to a destination. Third, it executes that path while constantly making tiny, rapid corrections to handle unexpected bumps or errors. The method was tested in simulations on three very different machines: a mathematical model of a vibrating system, a quadcopter drone, and a spacecraft attempting to land on the Moon. In every case, the system successfully identified the machine's true physical properties, calculated a safe trajectory, and guided the vehicle to a stable stop, even when the machine's actual behavior differed significantly from the initial assumptions.

The core of this work is a method for teaching a computer to learn about a machine while it is already in motion. Imagine a spacecraft descending toward a lunar surface. The engineers who built it have a best guess at how heavy it is and how much thrust its engine produces. But as the fuel burns, the craft gets lighter, and the engine might not be perfectly efficient. If the computer controlling the descent relies only on the original guesses, it might miscalculate the braking needed and crash. AMIGO solves this by dedicating an initial period of flight to "listening." During this phase, the machine moves under a safe, steady control while the computer watches how it reacts. By comparing the machine's actual movements against what the computer's model predicted, the system uses a mathematical technique to refine its understanding of the machine's weight and engine power. In the lunar landing simulation, this process allowed the computer to identify the engine's efficiency with an error of less than one-tenth of a percent, effectively learning the true nature of the spacecraft before the critical landing phase even began.

Once the system has a reliable model of the machine, it moves to the planning phase. Here, the computer does not just react to the present moment; it looks far into the future. It calculates a complete trajectory, a long list of commands that will guide the machine from its current position to a safe landing. This is not a simple straight line; it is a complex path that accounts for the machine's changing weight and the need to slow down gently. The computer solves this problem by working backward from the goal. It asks, "To be in the perfect spot at the end, where must I be a moment before that? And where a moment before that?" By repeating this logic, it builds a detailed plan that balances the need to reach the target with the need to use the least amount of fuel and effort. In the lunar example, this planning phase took about ten seconds of computer time to generate a path that would bring the craft from an altitude of 800 meters down to the surface, accounting for the Moon's gravity and the craft's changing mass.

The final phase is where the machine actually flies, guided by the plan but ready to adapt. This is where the system shines most brightly. The computer does not simply follow the pre-calculated path like a train on a track. Instead, it constantly re-evaluates the situation. Every fraction of a second, it looks at where the machine actually is, compares it to where the plan said it should be, and calculates a small correction. If a gust of wind pushes the drone off course, or if the engine performs slightly differently than expected, the system instantly computes a new, short-term adjustment to get back on track. This happens so fast that the machine never really deviates far from its intended path. In the simulation of the quadcopter, which had to stabilize itself while its weight and balance were unknown, the system identified the correct physical properties and then kept the drone steady, correcting its tilt and position continuously until it reached a hover.

The power of this approach lies in how it handles the limits of the machine itself. Real engines cannot push with infinite force, and they cannot change their power instantly; they have physical limits on how hard they can push and how fast they can change that push. Many control systems ignore these limits or try to work around them after the fact, which can lead to instability. AMIGO builds these limits directly into the planning process. When the computer calculates the path, it knows exactly how much force the engine can produce and how quickly it can change. If a maneuver requires more force than the engine can give, the system automatically adjusts the plan to stay within safe bounds. In the lunar landing scenario, the system managed the main engine's thrust and the smaller attitude-control motors to ensure the craft never demanded more than the hardware could deliver, keeping the descent smooth and safe.

The results of these simulations show that the system is robust enough to handle significant uncertainty. In the case of the quadcopter, the computer started with incorrect estimates of the drone's mass and the distribution of its weight. The initial guesses were off by a noticeable margin, yet the identification phase quickly corrected these errors. By the time the drone began its stabilization routine, the computer knew the drone's true physical properties with high precision. The final landing of the lunar lander simulation demonstrated the system's ability to manage a long, complex descent. The craft started 800 meters above the surface with a specific velocity and orientation. Over the course of the descent, the system identified the engine's efficiency, planned a trajectory that accounted for the fuel burn, and executed a soft landing. The craft touched down with a vertical speed of less than 6 centimeters per second, a gentle arrival that would be safe for a real mission.

What makes this work particularly notable is that it does not require the machine to stop or pause to learn. The identification, planning, and control happen in a continuous loop while the machine is moving. The system is designed to work within the strict time limits of a real computer. It knows that it cannot spend an infinite amount of time calculating the perfect path; it must produce a good enough answer before the next moment arrives. If the computer runs out of time, it simply uses the best plan it has calculated so far, ensuring that the machine never loses control. This balance between learning, planning, and acting allows the system to adapt to the real world, where conditions are never static and perfect information is never available.

The paper concludes that this method provides a solid foundation for guiding autonomous machines in difficult environments. It successfully demonstrated that a single system could learn the true nature of a machine, plan a complex trajectory, and execute that plan with precise corrections, all while respecting the physical limits of the hardware. The simulations covered a range of challenges, from a simple vibrating system to a complex spacecraft landing on another world. While the work was done in simulation, the results suggest that the approach is viable for real-world applications where safety and adaptability are paramount. The next step for this line of research would be to test the system on actual hardware and to explore how it might handle even more complex uncertainties, such as sudden changes in the environment or failures in the machine's sensors. For now, the work stands as a demonstration of how a machine can learn to fly itself, not by following a rigid script, but by understanding its own nature and adapting to the world around it.

Technical Summary: Adaptive Nonlinear Control with Online Identification and Receding-Horizon Optimization

Problem Statement
The paper addresses the challenge of controlling nonlinear dynamic systems where model parameters are imperfectly known, measurements are noisy, and actuator constraints (amplitude and rate limits) must be strictly enforced. A central difficulty in adaptive control is the synchronization of three competing requirements: the need for accurate state estimation and parameter identification, the computational cost of solving nonlinear optimal control problems, and the strict timing constraints of real-time execution. The author notes that standard formulations often assume fixed parameters and full state availability, which fails to capture the realities of physical systems where model parameters drift or are initially unknown, and where a newly computed policy must be available before the corresponding control instant.

Methodology: The AMIGO Framework
The paper proposes AMIGO (Adaptive Model-based Intelligent Guidance and Orchestration), a control scheme that integrates iterative Linear Quadratic Regulator (iLQR), state estimation, online parameter identification, and receding-horizon optimization. The core innovation is the organization of computation into three distinct Time Phases (TP) that occur sequentially in physical time, while state estimation runs continuously:

Identification Phase (TP1): The plant operates under a safe baseline control. If natural motion lacks sufficient information, bounded deterministic excitation is added. Measurements are processed by an Extended Kalman Filter (EKF), and model parameters are updated using the Levenberg–Marquardt (LM) method. This phase terminates when identification quality metrics (residual magnitude, rank, conditioning) indicate convergence.
Planning Phase (TP2): Using the identified model, a long-horizon nominal trajectory is computed. Crucially, this planning occurs while the plant is still moving, predicting the state at the start of the control phase rather than waiting for a hypothetical stationary handoff.
Control Phase (TP3): The nominal trajectory serves as a reference for closed-loop control. A shorter local problem with a receding horizon $H$ is solved periodically from the current state estimate. The resulting policy corrects the nominal trajectory segment. The previous local policy is reused as a warm start for the next solve to ensure computational efficiency.

Technical Implementation Details

Discretization and Dynamics: The nonlinear transition is evaluated using the fourth-order Runge–Kutta method (RK4). The iLQR algorithm linearizes these discrete dynamics along a nominal trajectory.
Quadratic Backbone: The optimization minimizes a finite-horizon cost function comprising state tracking errors, control effort, and control-rate penalties. The solution employs a backward dynamic-programming recursion to compute feedback gains and feedforward terms.
Constraints: The method explicitly handles amplitude constraints and control-rate limits. Rate limits are managed by augmenting the state vector with the previous control input. Constraints are enforced via an active-set procedure during the backward pass, where the solver iteratively fixes control components at their bounds and recomputes the remaining free variables, accounting for cross-coupling terms.
Computational Budget: The framework enforces a strict "computation budget" (wall-clock time limit) for each optimization step. If the budget expires, the system retains the best previously accepted policy, ensuring that control commands are always available in time.
Jacobian Evaluation: The paper highlights the computational cost of Jacobian evaluation and suggests that analytical derivatives or automatic differentiation are preferable to finite differences for long horizons.

Key Contributions

Integration of Phases: The explicit separation and sequencing of identification, planning, and control phases allow for adaptive model refinement without halting the physical system.
Constraint Handling in iLQR: The paper details a method for incorporating box constraints and control-rate limits directly into the iLQR backward pass using an active-set solver, preserving the quadratic structure of the value function.
Augmented State for Rate Limits: The formulation of rate limits via state augmentation ( $z_k = [x_k, u_{k-1}]^T$ ) allows for exact representation of control-rate penalties and constraints within the linearized model.
Robust Execution Strategy: The inclusion of a hard computation budget and a "warm start" mechanism ensures the system remains operational even if the optimizer cannot converge within the allotted time.

Results and Examples
The method is validated through three distinct examples:

Van der Pol Oscillator: A single-parameter identification problem where the unknown damping coefficient $\mu$ is estimated from 1.4 to 1.40259 (0.185% error). The controller successfully stabilizes the oscillator to the origin.
Nonlinear Quadcopter Stabilization: A 16-state benchmark involving multi-parameter identification (mass and moments of inertia). The system identified parameters with relative errors between 0.001% and 0.403%. The controller stabilized the quadcopter from a disturbed initial state to a hover, respecting actuator rate limits.
Autonomous Lunar-Lander Descent: A complex, variable-mass scenario inspired by the Beresheet mission. The system identified actuator efficiency factors with errors under 0.1%. The controller managed a descent from 800m, handling variable mass, quaternion-based attitude dynamics, and bounded thrust, achieving a soft landing with residual vertical velocity of approximately -0.058 m/s.

Significance and Claims
The paper claims that AMIGO provides a compact and effective framework for balancing trajectory-tracking accuracy against control effort in adaptive, nonlinear settings. By organizing operations into time phases, the method allows the optimizer to operate alongside state estimation and parameter identification without violating real-time constraints. The author emphasizes that the reverse-horizon quantities ( $P_{N-k}$ and $v_{N-k}$ ) explicitly demonstrate how every control law depends on the optimal cost of the future trajectory segment.

The paper remains modest regarding its scope, noting that the current formulation handles box constraints and rate limits but does not yet address general state or path constraints. It identifies future directions such as propagating parameter uncertainty directly into the optimization criterion (robust/stochastic extensions) and improving identifiability under poor excitation. The work is presented as a practical implementation of adaptive quadratic control that retains a valid policy even when optimization time is exhausted, making it suitable for safety-critical applications like autonomous landing.

More like this