Task-Level Iterative Learning Control

• Task-Level Iterative Learning Control is a methodology that updates controllers using trial-level performance data—such as KPIs, safe sets, or predictive models—rather than pointwise corrections.
• It distinguishes itself from classical ILC by focusing on repetition-wise tuning of complete task executions, enabling improvements in complex, nonlinear control problems.
• Applications in autonomous racing, robotic manufacturing, and deformable-object manipulation demonstrate its practical ability to rapidly adapt and optimize control performance.

Searching arXiv for papers on task-level iterative learning control and closely related formulations. Task-Level Iterative Learning Control denotes a class of iterative control methods in which information from prior executions of a repetitive task is used to improve performance at the level of an entire repetition, a task-defining parameterization, or a task-level performance summary, rather than only through pointwise time-indexed feedforward updates. In the recent literature, the term covers repetition-wise tuning of Nonlinear Model Predictive Control (NMPC) weighting matrices $Q$ and $R$ from key performance indicators (KPIs), lap-to-lap learned steering corrections for autonomous racing, reference-free learning MPC for iterative tasks, predictive ILC with disturbance forecasting across iterations, and object-centric updates defined at a critical event in deformable-object manipulation (Ingole et al., 15 Dec 2025, Kapania et al., 2019, Rosolia et al., 2016, Suresh et al., 24 Feb 2026). Across these formulations, the central premise is repeatability: data from prior trials are retained, summarized, or modeled, and then used to compute a better control action, controller parameter, value function, model estimate, or feedforward command for the next execution.

1. Conceptual scope and distinction from classical ILC

Classical ILC is typically formulated for a fixed repetitive trajectory and updates a time-indexed feedforward signal from trial to trial. In Kapania and Gerdes’ autonomous-racing formulation, the learned quantity is the lap-wise steering correction $\delta^L_j(k)$, and the task is repeated because the vehicle traverses the identical path each lap (Kapania et al., 2019). By contrast, the NMPC-tuning framework of “Iterative Tuning of Nonlinear Model Predictive Control for Robotic Manufacturing Tasks” updates the controller weights $Q$ and $R$ once per repetition, using task-level KPI feedback collected over the entire run; the learned variable is not a per-sample control sequence but the cost structure of the inner NMPC itself (Ingole et al., 15 Dec 2025).

This broadening of the learned object is characteristic of task-level ILC in the more recent literature. In Learning Model Predictive Control (LMPC), what is learned across iterations is a safe set and a terminal cost derived from previous successful trajectories rather than a conventional feedforward correction (Rosolia et al., 2016). In deformable-object manipulation, the learning objective can be concentrated on a single critical event in the object state, such as rope state at collision time in a flying-knot task, with command updates generated by a local inverse model (Suresh et al., 24 Feb 2026). Predictive variants further extend the concept by learning iteration-to-iteration drift and using the predicted next-iteration error in the update law (Nigam et al., 20 Feb 2026).

Formulation	Learned entity	Representative source
Classical lap-wise ILC	$\delta^L_j(k)$ steering correction	(Kapania et al., 2019)
Task-level NMPC tuning	$$W_\ell=[\operatorname{vec}(Q_\ell);\operatorname{vec}(R_\ell)]$$	(Ingole et al., 15 Dec 2025)
LMPC / ILMPC	safe set, terminal cost, policy	(Rosolia et al., 2016)
Predictive task-level ILC	predicted next-iteration error $\hat e_{i+1}$	(Nigam et al., 20 Feb 2026)
Object-centric task-level ILC	feedforward command update from $\tilde x_k$	(Suresh et al., 24 Feb 2026)

A common misconception is that task-level ILC is simply classical ILC executed more slowly. The surveyed formulations indicate a stronger distinction. In some cases, the update acts on controller parameters, terminal ingredients of an MPC problem, or a critical-point object-state target rather than on a time-series feedforward term. This suggests that “task-level” refers less to a single canonical algorithm than to a design pattern in which trial-level structure determines what is learned.

2. Mathematical formulations and update laws

A canonical mathematical starting point is the lifted-domain representation used in path-tracking ILC. For lap $j$, the tracking error satisfies

$R$0

where $R$1 is the lifted closed-loop map and $R$2 aggregates repeatable disturbance. Kapania and Gerdes describe both a proportional-derivative update

$R$3

and a quadratically optimal ILC update obtained by minimizing a convex cost on next-lap error, control magnitude, and lap-to-lap change. In lifted form, the quadratically optimal solution has the affine structure

$R$4

with $R$5 and $R$6 defined by $R$7, $R$8, $R$9, and $\delta^L_j(k)$0 (Kapania et al., 2019).

The task-level NMPC tuning formulation changes both the state of learning and the error definition. After repetition $\delta^L_j(k)$1, the measured KPIs are $\delta^L_j(k)$2, $\delta^L_j(k)$3, $\delta^L_j(k)$4, and $\delta^L_j(k)$5. These are normalized against user-defined targets to form $\delta^L_j(k)$6. The controller weights are row-stacked into

$\delta^L_j(k)$7

and the inter-repetition learning model is postulated as locally affine: $\delta^L_j(k)$8 Because analytic derivatives through the NMPC solver are not used, the sensitivity matrix $\delta^L_j(k)$9 is estimated empirically by perturbing each weight component, re-running the simulation, and measuring the resulting KPI change. The update is then computed from a norm-optimal quadratic criterion,

$Q$0

which yields the closed-form solution

$Q$1

The learned variables $Q$2 and $Q$3 are recovered from the corresponding blocks of $Q$4 (Ingole et al., 15 Dec 2025).

Predictive task-level ILC introduces an additional layer by forecasting iteration-to-iteration error evolution. In the Quasi-Periodic Gaussian Process Predictive Iterative Learning Control formulation, the standard ILC recursion

$Q$5

is augmented to

$Q$6

where the next-iteration error is predicted from a structural-equation quasi-periodic model,

$Q$7

Block prediction uses $Q$8, while element-wise prediction incorporates the covariance structure $Q$9 for sequential refinement. The resulting controller is designed so that the combined iteration operator is contractive and yields mean-square convergence of $R$0 when the spectral condition is satisfied (Nigam et al., 20 Feb 2026).

These formulations illustrate that the mathematics of task-level ILC is not restricted to one template. The learned variable may be a feedforward sequence, a controller-weight vector, or a predicted error profile; the error may be time-sampled tracking deviation, a KPI vector, or a critical-point object-state discrepancy. What is preserved is the inter-iteration feedback loop.

3. Integration with MPC and iterative optimal control

A major strand of the literature embeds task-level learning inside receding-horizon control. In LMPC for iterative tasks, the controller solves at each time $R$1 and iteration $R$2 a finite-horizon optimal control problem with terminal constraint $R$3, where the sampled safe set $R$4 is the union of states visited in previous successful iterations. The terminal cost

$R$5

is built directly from stored cost-to-go data. The reported guarantees are recursive feasibility and non-increasing iteration cost, namely $R$6 (Rosolia et al., 2016).

Vallon and Borrelli extend this logic through task decomposition. Their Task Decomposition for Iterative Learning Model Predictive Control considers two tasks composed of the same subtasks in different orders. Stored data from $R$7 are recombined to initialize ILMPC on $R$8 by proceeding backward over the new subtask order and checking one-step controllability of sampled guard states into the next subtask’s stored state set. The resulting TDMPC initialization provides a nonempty feasible safe set for the new task order when the stated assumptions hold, and the paper reports both feasibility and iteration-cost improvement over simple initializations (Vallon et al., 2019).

Robust and stochastic variants further broaden the task-level perspective. Robust LMPC for linear systems with bounded additive disturbance constructs a convex robust control invariant safe set $R$9 from forward reachable sets of previous closed-loop executions, together with a convex piecewise-affine value function $\delta^L_j(k)$0 and an associated safe policy $\delta^L_j(k)$1. An adaptive prediction horizon selects when to switch from disturbance-feedback planning to the stored safe policy, with guarantees of recursive feasibility, input-to-state stability, performance bounds, and non-shrinking domain (Rosolia et al., 2019). SIT-LMPC formulates the iterative problem as an information-theoretic MPC problem with an adaptive penalty method for safety and a normalizing-flow value function learned from previous feasible trajectories. The implementation is designed for GPU parallelization and is reported to achieve $\delta^L_j(k)$2 on NVIDIA Jetson Orin AGX with $\delta^L_j(k)$3, $\delta^L_j(k)$4, and $\delta^L_j(k)$5 (Zang et al., 18 Feb 2026).

The i2LQR formulation occupies a related but distinct position. It is reference-free, uses historical state and realized cost-to-go data, and at each time step solves multiple candidate local trajectory optimization problems by iLQR against candidate terminal states drawn from history. Unlike LMPC, it does not force the terminal state to lie in a fixed historical safe set; instead it penalizes terminal mismatch to a nearby historical state and uses smooth penalties for current constraints and obstacles. In the reported simulations, i2LQR matches LMPC in static environments and outperforms it in dynamic environments with added static or moving obstacles (Zeng et al., 2023).

Taken together, these methods show that task-level iterative learning and MPC are deeply intertwined in contemporary work. The task-level object of learning may be a safe terminal ingredient, a value approximation, a penalty selection mechanism, or controller weights inside an inner NMPC loop.

4. Empirical regimes and representative applications

Robotic manufacturing provides a clear example of outer-loop task-level adaptation. In the UR10e carbon fiber winding study on a regular tetrahedron with edge $\delta^L_j(k)$6, the open-loop planner used NMPC with horizon $\delta^L_j(k)$7 and $\delta^L_j(k)$8, while the closed-loop tracking NMPC used the same horizon and sampling with tunable $\delta^L_j(k)$9. Offline Bayesian Optimization required 100 weight evaluations to find $$W_\ell=[\operatorname{vec}(Q_\ell);\operatorname{vec}(R_\ell)]$$0. The online ILC-tuned NMPC initialized $$W_\ell=[\operatorname{vec}(Q_\ell);\operatorname{vec}(R_\ell)]$$1 and $$W_\ell=[\operatorname{vec}(Q_\ell);\operatorname{vec}(R_\ell)]$$2, computed KPIs after each winding repetition, and converged to near-optimal RMSE within $$W_\ell=[\operatorname{vec}(Q_\ell);\operatorname{vec}(R_\ell)]$$3 of BO in 4 repetitions, described as 25× fewer tuning calls. The reported comparison was RMSE $$W_\ell=[\operatorname{vec}(Q_\ell);\operatorname{vec}(R_\ell)]$$4 versus $$W_\ell=[\operatorname{vec}(Q_\ell);\operatorname{vec}(R_\ell)]$$5, maximum error $$W_\ell=[\operatorname{vec}(Q_\ell);\operatorname{vec}(R_\ell)]$$6 versus $$W_\ell=[\operatorname{vec}(Q_\ell);\operatorname{vec}(R_\ell)]$$7, RMS control rate $$W_\ell=[\operatorname{vec}(Q_\ell);\operatorname{vec}(R_\ell)]$$8 versus $$W_\ell=[\operatorname{vec}(Q_\ell);\operatorname{vec}(R_\ell)]$$9, and computation time per repetition $\hat e_{i+1}$0 versus $\hat e_{i+1}$1 (Ingole et al., 15 Dec 2025).

Autonomous racing is a foundational high-dynamics example. Kapania and Gerdes tested PD-ILC and Q-ILC on an Audi TTS race vehicle at Thunderhill Raceway, with baseline feedback-feedforward steering at $\hat e_{i+1}$2, ILC updates at $\hat e_{i+1}$3, and lateral accelerations of up to $\hat e_{i+1}$4. Baseline feedforward-feedback alone produced transient error spikes of $\hat e_{i+1}$5–$\hat e_{i+1}$6 during high-$\hat e_{i+1}$7 entries. PD-ILC reduced peak transients within 2–3 laps, and RMS lateral error dropped from approximately $\hat e_{i+1}$8 on lap 1 to approximately $\hat e_{i+1}$9 on lap 4; Q-ILC yielded comparable convergence speed and steady-state RMS (Kapania et al., 2019). Predictive variants extend this regime to slowly varying disturbances: QPGP-PILC on simulated vehicle trajectory tracking reached steady error in approximately 45 laps in block mode and approximately 30 laps in element mode, compared to approximately 100 laps for standard ILC and approximately 60 laps for conventional GP-PILC, while reducing compute cost relative to GP-PILC over 100 iterations (Nigam et al., 20 Feb 2026).

Dynamic manipulation of deformable objects shows a different task-level emphasis. Suresh and Atkeson formulate a flying-knot problem in which learning targets the rope state at a single critical collision time $\tilde x_k$0. The error is

$\tilde x_k$1

and a convex Quadratic Program maps $\tilde x_k$2 into a feedforward command correction $\tilde x_k$3 under joint position, velocity, acceleration, and torque limits. The reported hardware evaluation covers 7 rope types, including chain, latex surgical tubing, and braided and twisted ropes, with thicknesses of $\tilde x_k$4–$\tilde x_k$5 and densities of $\tilde x_k$6–$\tilde x_k$7. Learning achieved a $\tilde x_k$8 success rate within 10 trials on all ropes, and transfer between most rope types required approximately 2–5 trials (Suresh et al., 24 Feb 2026).

Task-level iterative learning has also been used to adapt task difficulty rather than plant commands. In stroke-rehabilitation simulation, the prescribed sine-wave amplitude $\tilde x_k$9 is updated trial-by-trial according to

$j$0

with $j$1 capped at 1. Over 20 trials and 100 randomly initialized networks per condition, the mean $j$2 for one NARX architecture fell from approximately 1.0 at $j$3 to approximately 0.35 by $j$4, while a rule-based strategy plateaued earlier at approximately 0.45. Healthy participants under the simulation reached approximately $j$5 mean amplitude by trial 20 with ILC versus approximately $j$6 for the rule-based approach; the stroke condition reached approximately $j$7 versus approximately $j$8 (Noble et al., 2021).

Additional application domains highlight scalability and task flexibility. Dual Iterative Learning Control for unknown MIMO dynamics reports that many reference tracking tasks are solved within 10–20 trials, with complex motions learned in less than 100 iterations; in the planar two-link robot, one configuration solved all three tasks within 50 trials, and in a three-wheeled inverted pendulum the reported error reduction exceeded $j$9 within 20 trials (Ewering et al., 23 Sep 2025). TAIL-ILC addresses non-repetitive but structurally similar tasks by imitating expert ILC policies in a DPCA latent space; for a moving-magnet planar actuator, it reported $R$00 training time versus $R$01 for NN-ILC, $R$02 full-signal prediction time versus $R$03, and peak tracking error $R$04 versus $R$05 on the first degree of freedom (Vinjarapu et al., 2023).

5. Assumptions, guarantees, and limitations

The strongest guarantees in task-level ILC remain tied to repeatability. In autonomous racing, the disturbance term $R$06 is assumed nearly identical each lap; large lap-to-lap variation in surface friction or wind degrades performance, and if front tires saturate under understeer, additional learned steering has no effect (Kapania et al., 2019). In the NMPC-weight adaptation framework, convergence relies on a valid local affine approximation $R$07; the authors explicitly note that large weight changes may invalidate this linear model (Ingole et al., 15 Dec 2025). In DILC, monotonic model convergence requires the stated conditions on $R$08 and persistency of excitation, and the authors note that in point-to-point stops one may need injection of dither or regional linear models (Ewering et al., 23 Sep 2025).

Convergence statements differ by formulation. For PD-ILC, monotonic convergence of the error norm is guaranteed when the spectral norm condition

$R$09

holds; for Q-ILC, the corresponding iteration operator must have eigenvalues strictly inside the unit disc under positive-definiteness assumptions on $R$10, $R$11, and $R$12 (Kapania et al., 2019). The NMPC-tuning method attributes its observed rapid error reduction to a regularized Gauss–Newton update under a local affine assumption (Ingole et al., 15 Dec 2025). Predictive QPGP-based ILC establishes mean-square convergence by making the combined operator contractive with respect to the learned quasi-periodic iteration model (Nigam et al., 20 Feb 2026). LMPC and its robust variants replace classical ILC monotonicity arguments with recursive-feasibility, safe-set invariance, input-to-state stability, and non-increasing performance claims (Rosolia et al., 2016, Rosolia et al., 2019).

A second misconception is that task-level ILC is necessarily model-free. The surveyed methods indicate otherwise. Some are explicitly data-driven and self-parametrizing, as in DILC’s simultaneous model learning and feedforward update (Ewering et al., 23 Sep 2025). Others are model-based or hybrid. Autonomous-racing ILC uses a linearized bicycle-model response to construct the lifted matrix $R$13 (Kapania et al., 2019). Flying-knot learning depends on a simplified rope model and a locally linear inverse map solved as a QP (Suresh et al., 24 Feb 2026). LMPC, robust LMPC, SIT-LMPC, and i2LQR all embed iterative learning inside finite-horizon optimal control formulations with explicit state, input, or safety structure (Rosolia et al., 2016, Zang et al., 18 Feb 2026, Zeng et al., 2023).

A third limitation concerns task flexibility. TAIL-ILC explicitly addresses the fact that classical ILC is generally not applicable to non-repetitive motion tasks, but its own DPCA construction requires fixed-length trajectories, and the paper notes that arbitrarily varying duration is not directly handled (Vinjarapu et al., 2023). Similarly, the NMPC-weight tuning framework states that current work treats static tasks and that extension to time-varying or multi-task scenarios requires re-estimating or adapting the sensitivity matrix $R$14 (Ingole et al., 15 Dec 2025).

6. Extensions and emerging directions

Several current directions extend task-level ILC beyond strictly stationary repeated trials. Predictive modeling of drift across iterations is one such direction. The QPGP structural-equation model was introduced specifically to maintain convergence under time-varying disturbances while keeping inference complexity fixed at $R$15, independent of the number of prior iterations $R$16 (Nigam et al., 20 Feb 2026). This suggests a shift from purely reactive repetition-to-repetition correction toward inter-iteration forecasting.

Another direction is cross-task transfer. TDMPC reuses subtask data from one ordering to initialize ILMPC on another ordering of the same subtasks, and the reported racing and manipulation examples show faster initial performance on the recombined task (Vallon et al., 2019). The flying-knot experiments report transfer between most rope types in approximately 2–5 trials after learning on a single demonstrated rope, indicating that task-level learning can remain effective even when material parameters vary substantially (Suresh et al., 24 Feb 2026). TAIL-ILC generalizes expert ILC feedforward to unseen trajectories within a trajectory class by learning a latent-space imitation policy rather than re-running ILC on each new reference (Vinjarapu et al., 2023).

A further direction is integration into broader autonomy stacks. DILC is explicitly proposed as a building block within kinodynamic planners, hierarchical task learners, and adaptive model-predictive frameworks, with future work aimed at embedding the method into full autonomy stacks that combine perception, planning, and rapid task-level learning (Ewering et al., 23 Sep 2025). SIT-LMPC similarly emphasizes GPU-parallel execution and real-time optimization in uncertain constrained environments (Zang et al., 18 Feb 2026). The NMPC-tuning study identifies hardware validation, automatic adaptation to tool wear, and environment shifts as future work (Ingole et al., 15 Dec 2025).

Across these developments, task-level ILC appears less as a narrow subfield than as a unifying control principle for repetitive tasks: retain structured information from prior executions, choose a task-relevant object of learning, and update that object between iterations so that the next execution improves. The particular object of learning may be a feedforward trajectory, a KPI-weight vector, a safe set, a value function, a local inverse model, or a predictive disturbance representation, but the underlying logic remains trial-to-trial performance refinement grounded in repeated task execution.