Differentiable Model Predictive Control on the GPU
Authors: Emre Adabag
Marcus Greiff
John Subosits
Thomas Jonathan Lew
Venue: ICLR 2026 Oral (2026)
Keywords: differentiable optimization
model predictive control
optimal control
gpu-accelerated optimization
reinforcement learning
imitation learning
robotics
Primary area: applications to robotics, autonomy, planning

Abstract: Differentiable model predictive control (MPC) offers a powerful framework for combining learning and control. However, its adoption has been limited by the inherently sequential nature of traditional optimization algorithms, which are challenging to parallelize on modern computing hardware like GPUs. In this work, we tackle this bottleneck by introducing a GPU-accelerated differentiable optimization tool for MPC. This solver leverages sequential quadratic programming and a custom preconditioned conjugate gradient (PCG) routine with tridiagonal preconditioning to exploit the problem's structure and enable efficient parallelization. We demonstrate substantial speedups over CPU- and GPU-based baselines, significantly improving upon state-of-the-art training times on benchmark reinforcement learning and imitation learning tasks. Finally, we showcase the method on the challenging task of reinforcement learning for driving at the limits of handling, where it enables robust drifting of a Toyota Supra through water puddles.

Published as a conference paper at ICLR 2026
DIFFERENTIABLE MODEL PREDICTIVE CONTROL ON THE GPU
Emre Adabag, Marcus Greiff, John Subosits, Thomas Lew Toyota Research Institute
ABSTRACT
Differentiable model predictive control (MPC) offers a powerful framework for combining learning and control. However, its adoption has been limited by the in- herently sequential nature of traditional optimization algorithms, which are chal- lenging to parallelize
modern computing hardware like GPUs. In this work, we tackle this bottleneck by introducing a GPU-accelerated differentiable opti- mization tool for MPC. This solver leverages sequential quadratic programming and custom preconditioned conjugate gradient (PCG) routine with tridiagonal preconditioning exploit the problem's structure and enable efficient paralleliza- tion. We demonstrate substantial speedups over CPU- and GPU-based baselines, significantly improving upon tate-of-the-an training times on benchmark rein- forcement learning and imitation learning tasks. Finally, we showcase the method on the challenging task of reinforcement learning for driving the limits of han- dling, where it enables robust drifting of Toyota Supra through water puddles.
Code: Bttp:://gghhab...m/pppptaaeeeeee
/diffmpc
INTRODUCTION
Differentiable optimization tools enable leveraging the structured and precise outputs of optimiza- tion algorithms as inductive biases in machine learning, reducing data requirements and enforcing constraints. These methods also enable data-driven tuning of optimization algorithms,, reducing üme-consuming manual expert-driven development using data. In particular, differentiable model predictive control has many applications, such in motion planning (Bhardwaj et al., (020),, pa- rameter estimation (Landry et al. 2019) and tuning (Cummins et al. (025), reinforcement learning (Romero al., 2024), imitation learning (Grandia al. [203]] Wan et al. 2024). and end-to-end
planning and control (Amos et al.
2018 Karkus et al. (023).
However, the adoption of differentiable optimization hindered by the sequential nature of opti- mization tools: Efficient parallelization on graphics processing units (GPUs) remains difficult, both for solving the optimization problem (the forward pass) and for computing gradients (the backward pass). Recent methods for differentiable optimal control, such as (Bambade et al., 2024, Frey et al., 2025) only run on central processing units (CPUs) to leverage the time-induced sparsity of optimal control problems (OCPs) via sequential algorithms such the iterative linear quadratic regulator (iLQR) (Amos et al., 2018). Overcoming this computational bottleneck could enable scaling up to large datasets and expressive architectures, fully utilizing the benefits of modern deep learning.
Contributions: We propose Differentiable Model Predictive Control (Di f EMPC): new tool for differentiable optimal control to solve and differentiate through optimal control problems of the form
T-1
OCP:
arg min
Σ 2.0 (xx) + Σ c (w,) t=0
s.t. ff u.) = 0. 20 = x
==(x,u)
t=
where the costs, equality constraints, and initial conditions are parametrized by parameters 0, which could represent the weights of a neural network (parameterizing the cost c(-) or constraints f())), the outputs of intermediate neural network layer, the parameters of physics-based model. Dif f fMPC is tailored for execution on the GPU by leveraging the structure of OCP: The core of the solver is a preconditioned conjugate gradient (PCG) routine introduced in (Adabag al. 2024) to

---

Published as a conference paper at ICLR 2026
solve the linear system arising from the optimality conditions of OCP. This routine leverages the sparse structure of OCP to expose parallelism over time t. and enables warm-starting across problem instances. DiffMPC is written in JAX to simplify deployment in machine learning applications. Numerical and experimental results using D f EMPC show the following:
Significant acceleration on the GPU: Comprehensive benchmarking against the state-of-the the- art differentiable optimization libraries mpc pytorch (Amos et al. 2018). t trajax (Frostig) eet al.) (02T), and Theseus (Pineda et al. 2022) show consistent speedups of more than 4x when solving and differentiating OCP. These experiments include reinforcement learning (RL) and imitation learning (IL) examples, which are common applications of differentiable optimal control. These speedups primarily come from a PCG routine tailored for GPU execution and several related design choices in Di EMPC that exploit problem structure for parallelization.
Reliably drifting a Toyota Supra via domain randomization and reinforcement learning: We use Di f fMPC to automatically tune an MPC controller for driving at the limits of handling and ensure robustness to model mismatch, such as water puddles on the road. Specifically, we use domain randomization over the nonlinear dynamics to learn cost and vehicle parameters for the controller via reinforcement learning. In this application, due to the unstable nature of driving at the limits of handling where tire forces are saturated and the vehicle is prone to spinning out, large batches are conducive to robust training, motivating the use of the proposed GPU- accelerated differentiable optimization framework. Results demonstrate significantly improved performance a Toyota Supra drifting through water puddles (Figure
2
BACKGROUND ON DIFFERENTIABLE OPTIMIZATION
2.1 RELATED WORK
Recent years have a surge of works on scalable optimization algorithms that efficiently on
the GPÚ (Schubiger et al. 2020 Chen et al.] 22044 Kang et al. 2024 Feng et al.) 2022]] Bishop et al.)
2024 Adabag et al. [024]] Chari al.] [024;] Jeon et al.) [024] Amatucci et al. [025 Montoison & Caillau 2025), enabling large-scale validation and parameter sweeps. However, as optimiza-
tion algorithms are inherently sequential, GPU-accelerater solvers are often slower than CPU-based
solvers when solving small- to medium-sized problems individually. Among these efforts, MP MPCGPU (Adabag et al. 2024) exploits the sparse-in-
pparse-in-time in-time structure of OCP using a tailored preconditioned conjugate gradient (PCG) routine. As result, it achieves fast replanning times for MPC applications that match or outperform state-of-the-arr CPU-based solvers, even for single problem instances. This work highlights the importance of taking advantage of problem structure to fully exploit GPU par- allelism. Still, these solvers are not differentiable and thus do not provide sensitivities with respect to problem parameters.
Differentiable optimization tools address this gap by enabling the computation of gradients of solu- tions to optimization problems with respect to parameters, supporting wide range of applications
(see Section T. These tools fall into two main categories, general-purpose solvers (Ren et al. 2023
Arnold et al. 2020 Deleu et al. 2019 Pineda al. 2022, DeepMind al.] [020 Blondel al.
2022) and structure- exppoiir- solvers for MPC (Amos et al. 2018) Agrawal et al. 2019: Frostig
ct al. 102 Howell et al., 2022. Bambade et al. 2024 Frey et al. (025)..
General-purpose differentiable solvers often support GPU execution and can be applied broadly. However, in MPC applications, they are typically slower than OCP-specific solvers, they do not sufficiently leverage problem structure. For example, solving OCP using Theseus (Pineda et al.; 2022) by rolling out control inputs through the dynamics as in (Wan et al., 2024) can be orders of magnitude slower than using Di f FMMC (see Section 4.
On the other hand, OCP-tailored solvers exploit problem structure for efficiency, but usually only support CPU execution (Amos& & Kolter] 2017) Agrawal et al. 2019 Howell et al. 2022 Bambade al. 2024 Frey et al. 2025), which can limit their scalability in large-batch or learning applications. The closest methods to Diff are mpc . pyytocct (Amos et al. 2018) and trajax (Frostig)
et al. 2021), which support GPU execution and exploit the inducdd sparse structure of OCP. However, both methods rely on Riccati recursions over time
0, 0,...,Ty TT requiring relatively
large batch sizes to realize speedups on the GPU. As shown in Section 4 DifEMPC avoids these
recursions using a tailored PCG routine, enabling significant speedups over existing methods.
2

---

Published as a conference paper at ICLR 2026
2.2 A PRIMER ON DIFFERENTIABLE OPTIMIZATION
l
Next, provide background on differentiable optimization (DO) used in the design of D EMPC. Consider the generic parametric, equality-constrainee optimization problem
Forward Pass
P: 2 = arg min f2, f) subject to g(2, 8) = O,
=ER"
where 2 In are optimization variables, 0 E Rº are parameters. R x RR IR is cost function, and g IR x I - IR defines equality constraints. The solution 2 20) and its associ- ated Karush- Kuhn- Tucker (KKT) multipliers À x(0) E R must satisfy the KKT conditions
Backward Pass
2
Figure DO solves opti-
mization problems in (the
P(2,,,01 = V.I(,,,,0
V=J(2, () V =((,)))
0, forward pass) and computes sensitivities with respect to parameters O (the backward pass), moving along the loss surface & defined by the opti- mization problem.
VxL(2,X,0)
g(2,0)
(1)
where L(2, ((=,0) + A 9(z, 0) is the Lagrangian of P.
The forward pass consists of solving the optimization problem P. Many solvers leverage the structure of P and its KKT conditions, such as its sparsity, to enable efficient numerical resolution. In the context of optimal control, for instance, the iLQR method leverages the sparse-in-ting structure of OCP and uses Riccati recursions to break the optimization problem into smaller one-step problems that are solved recursively over time however, iterative and do not fully leverage the parallelism of GPUs.
0, T (Amos al. (2018). These operations are,
The backward pass computes the sensitivities of the solution to P with respect to the parameters 0. For efficiency, many methods use the implicit function theorem (IFT) for this sensitivity computation (Gould al. 2016 Amos & Kolter 2017): By defining the primal-dual pair w= solving P.
dF
OF Ow d0 Ow 00
OF
aw aF 8w
OF
OF
V V.LL V.g
+
00
0
00
30
where
Ow
=
x9
(2)
where we used F(z, X, 0) 0 so that dF 0 in the first equality. The invertibility of the KKT
do
matrix #F follows from the IFT under suitable assumptions (Lee 2012 Blondel & Roulet 2024
De
Thus, computing the sensitivity matrix dw
50 requires solving p linear systems Thr 36,
OF dw 20, which
enables computing Jacobian-vector products (JVP) for downstream uses. machine learning ap- plications, one typically uses the gradient of function & R" + RR of the solution to P. Such gradients can be more efficiently computed using the vector-Jacobian product (VJP)
de
Ow T aE T
Ow
at 0= 0
OF
[OFT dw
(3)
00
00
Dw
00
de
[0]
Computing the VJP in (3) only requires solving one linear system @F = oz 0), and is thus more efficient than using JVP, see Appendix for further details.
Efficiintt differentiable solvers leverage the structure of P to quickly compute solutions and exploit the sparsity structure of the KKT matrix 8F solve the linear system of = ( (a= 0) evaluate
the VJPs in 3 In the next section, describe such solver for optimal control problems that is designed to leverage parallelism to run efficiently on the GPU.
DIFFERENTIABLE MODEL PREDICTIVE CONTROL ON THE GPU
DiffMPC enables solving and differentiating through optimal control problems (OCPs) of the form
OCP:
arg min ==
Σ (x.))
Σ
c s.t. S ff 24, u.) = 0, 30 = x v.O (we)
1=
with separable costs of c. 0 the next sections, we describe its forward pass (solving OCP), its backward pass (computing gradients with respect to 0), and discuss design choices for efficient deployment the GPU.
equality constraints f. and initial conditions z parametrized by
3

---

Published as a conference paper at ICLR 2026
3.1 FORWARD PASS: SOLVING OCP VIA SEQUENTIAL QUADRATIC PROGRAMMING (SQP) To solve OCP, which is in general non-convex, use the sequential quadratic programming (SQP) scheme with a line search in Algorithm At each iteration the SQP scheme, given an initial guess for the solution 2, approximate the cost of OCP by linear-quadratic function and linearize the dynamics constraints, to obtain the parametric quadratic program (QP):
T QP: min Σ (=r,,)) 1=0
T-1
u0 Qu Fet
Σ
u uu Rou tri s.t. A #14111 + A B To -o-
where= = (zo, uo JT-1; 2T-1, and (Q. g. R, A+, A, C) depend on the parameters 0, and are computed in parallel over OCP problem instances and time steps i = o,..., T.
(Q), (V c/ (at), VGG V (zx)), (Ra, = (V v. (we), Ve, (we), (A) Ar, B₂) == (V (Vzmn (I141, Tz, ue), Va.S% (T, ue), V V., fl (2441, ue)).
(4a)
(4b)
and C. := A r1+1 + ArT + B f (I1+1, Tt. uz). To ensure that the matrices (Q, R) are
positive definite, we project them onto the positive definite cone as in (Singh et al. 2022 Since the cost quuar-qua and the equality constraints are linear, the KKT matrix of QP is
QQ
OF Ow
G H H
Ro
Ao Bo A
where G
and =
(5)
Ar Br A
Solving QP consists of finding a pair (z, A) satisfying the KKT conditions in I and takes the form:
G
H
A
H
0
where 6 = (go, Fo, T1, (N) and d = (It, Co...,, CT-I).
3.2 BACKWARD PASS: COMPUTING SENSITIVITIES VIA THE IMPLICIT FUNCTION THEOREM
Given solution z to OCP computed via SQP, Di DifRl EMMPC computes the sensitivities with respect to 0 using (3) (see Algorithm 2}. The most expensive step consists of solving the linear system
G
H
BF Dz
(2)
(7)
This linear system the same as the linear system in 66) used for the forward pass, with (-b, d) replaced with de 0). Importantly, the KKT matrix pre-computed the forward pass.
3.3 SOLVING THE LINEAR SYSTEMS WHILE LEVERAGING PARALLELISM
The efficiency DiFIMPC relies on an efficient and GPU-friendly routine for solving the linear systems (6) and (7) that leverages the structure of the KKT matrix in (5) Specifically, Di EMPC uses the preconditioned conjugate gradient (PCG) method with tridiagonal preconditioning (Bu & Plancher 2024) introduced in (Adabag al. 2024). We briefly describe this method below.
To solve the linear system 6 we first form the Schur complement of the KKT system
S HGGHHHH
7: '
(8)
and solve for X and z sequentially:
SA -\=10
== = T
Solving 7 is done similarly, by replacing (-b, d) with ( 0). When solving the smaller system in 19. we exploit the structure of S and use a symmetric stair preconditioner (Bu & Plancher 2024):
Q
of da
Qo
- -oo0 X
Xo 01
Xo 2oQo
Xo
-Xo Φ Xi
T
S
Xi 21
Xi
(10)
ΦN XN-2 6T-1
ΦT
-T
4

---

Published as a conference paper at ICLR 2026
where X A,QT'AA
A B
and oi = -
with A I. The
solution to 2 is then computed using the PCG method, summarized in Appendix A.2 (see Algo-
rithm 3). Similarly, for the second step in p using the structure present in (G, H), the variables
21 Dee u4) are computed parallel over / == 0,..,, T to maximize efficiency on the GPU:
Tt -
Q - (at + A--1A + A,
" =
(Te -
R
Bi dct1).
(11)
for all t T 1, with A I with the last state given by FT -Q (gr + AA
While PCG is an iterative routine, we found that it particularly suitable for differentiable optimiza- tion on the GPU 1) the preconditioner Φ-1 reduces the condition number of S while retaining the parallel-friendly block-tridiagonal structure of S, thus enabling parallelization, and 2) its warm- starting capabilities, which are useful when repeating calls DifÉMPC in an MPC setting.
3.4 ADDITIONAL IMPLEMENTATION DETAILS AND PROPERTIES OF DIFFMPC
Next, we describe details and design choices of Di f fMPC that optimize for speed and parallelism.
Line search:
After solving QP, a standard line search (Nocedal & Wright 2006
Algorithm 18.3)
used select an appropriate step towards the solution of OCP. The merit function is defined as weighted sum of the cost and constraints, and is evaluated in parallel over different predefined step sizes to further leverage GPU parallelism. Details about the line search are Appendix AA.3]
Warm-starting and reusing computations: The forward and backward passes of Di FMPC can be warm-startee with previously computed solutions the SQP and PCG loops. Also, since the KKT matrix for the forward pass is the same for the backward pass, multiple matrices from the forward pass are passed to the backward pass instead of being recomputed. Figure summarizes data flows.
To form QP, an exact SQP scheme would use cost matrices corresponding to the Hessian of the Lagrangian OCP (Nocedal & Wright 2006) (Q, == V I. V V2A f. which requires using the KKT multipliers associated with the equality constraints and additional modifications (e.g., Geuss-Newton approximations) to ensure reliable descent on the problem and that (Q, Rt) are positive definite. Similarly, the constraints curvature could be accounted for in the backward pass, leading to a different KKT matrix (see, e.g., Frey et al. (025)). As in (Amos et al. 2018) (and as is standard practice in SQP (Jordana et al. (225)) and done in iLQR), curvature of the dynamics to formulate the cost matrices of QP as (Q, R) == Vhe and rely on a line search for robustness. This scheme may result in degraded accuracy for the gradients (see e.g. (Frey iet al. 2025) Figure 2)). However, it is easier to implement, works well in many applications, and does not require computing second-order derivatives of the constraints that can be computationally expensive to evaluate.
Exact SQP vs iLQR:
neglect the
Parallelism, DifEMPC vs iLQR: Classical algorithms for solving OCP such iLQR Ric- cati recursions, and thus operate sequentially over time t = ...... T to solve OCP. In contrast, DifEMPC benefits from multiple sources of parallelism over time steps. First, all matrices are eval- uated in parallel for each SQP iteration (e.g., (Qt, Rd, Ar.... ) and blocks of (S, x b)1)). Second, while the PCG routine (Algorithm (3) is iterative, it leverages parallelization over time t for both the forward and backward passes. The warm-starting capabilities of PCG enable fast numerical reso- lution in MPC applications, whereas the Riccati recursions of iLQR do not leverage warm-starting over problem instances. Leveraging parallelism, warm-starting capabilities, and batching over prob- lem instances makes D DifIMPC well-suited for learning policies on the GPU.
3.5 REMENTRCEMENT LEARNING AND IMITATION LEARNING
DiffMPC is a fully differentiable policy, making it compatible with standard learning paradigms such reinforcement learning (RI.) and imitation learning (IL):
H
RL: max E
Σ
R(a, n (Ix))
T++1 SimEnv(a,, T (xt)) Ti
Dinitial states
(12)
II:
min E [i)........ wr) - (xt))
(wo, uo.... wr) ~ D demonstrations
(13)
with an MPC policy d parametrized in 0:
MPC Policy: TZo( (ug. ..) where (ag ug.... ,T) solves OCP.
)
(14)
5

---

Published as a conference paper at ICLR 2026
Forward
Algorithm Forward Pass (SQP).
Inputs: Initial guess (z, A), Tolerance
while not converged do
Evaluate (Q. R. B.C.
2: Evaluate (Q, R, q, A, C)
Eq.
3: Evaluate (S.7.
Eq.
4: À x PCGGSS
Alg.
(2
(8.2)
5: Evaluate QP solution (2 +
Eq
Linesearch
6: (z, u) Linesearch(
u)
Sec.
7: Return: Solution (a,, u, A), QP matrices
(Q, ...... Schur matrices (S, 1-
Algorithm Backward Pass (sensitivities).
PCG
Inputs: Forward pass solution (æ, u) and ôe Initial
(2,8,0
matrices (S, $ 1) Loss gradient 0s*
guess À
(gp À)
Evaluate 7 uusing (-b, d) 2: À PCG(S, 7, x- --1,
0)
Eq.
Alg.
Evaluate Σ uuiin À
Eq
Backward
4: Evaluate ae 86
ar 80
Eq.
Figure 2: DifÉMPC architecture: forward and backward passes, data flows, and main steps.
Return: Gradient
solution Ā
30
In (1),, R is reward function, SimFnv is simulator for the environment, and Dinitial states is distribution over initial states. In (13). D Pdemonstrations provides demonstration samples for imitation learning. In this work, we conduct RL using a differentiable simulation environment, though this is not required as Di FMPCC could be used as a component of other diffcrentiable policy architectures. Compared to black-box policies, Di f FMPC can leverage physics-informed inductive biases through its dynamics model and through solving OCP. Its gradients can be computed as deseribed in the previous section. Since the algorithm is tailored for GPUs, large batch sizes can be used for training.
RESULTS: FASTER SOLVES AND LEARNING ON THE GPU
We implement Di EMPC in JAX and evaluate it on reinforcement learning and imitation learn- ing tasks. We compare it with three state-of-the-art differentiable solvers: the PyTorch-based nonlinear least-squares solver Theseus (Pineda et al. 2022). the PyTorch-based iLQR solver mpc. pytorhh (Amos et al. 2018), and the -axed iLQ solver Trajax (Frostig al. 2021)
4.1 TIMING RESULTS FOR REINFORCEMENT LEARNING
We consider randomly-generated MPC problems with quadratic costs and affine dynamics con- straints. Details about problem randomization are in the appendix. Since the problems convex, we disable the line search for all methods and restrict all solvers to a single iteration, which enables fairer comparison. The RL task consists maximizing the reward R(x, u) := -[1==1| + [|ul(2) aggregated over 50 environment time steps for batch size of 64 randomized environments, by learn- ing the MPC's quadratic cost parameters. Forward- and backward-pass computation times measure the time to compute the aggregate reward over batched rollouts and their gradients with respect to the cost parameters. Statistics for each problem are averaged over 10 seeds. Details are in Appendix B.I along with additional results on other problems.
Comparison of computation times. Figure compares solve times of the different solvers. First, for this problem (and all tested, see Table in the appendix), Theseus is the slowest, exceeding 80 sec when run on the CPU. This slowdown likely due to not sufficiently exploiting the time- induced sparse structure of OCP. Second, mpc.pytorch and trajax are not significantly faster on the GPU than on the CPU, which can be attributed to their design based on sequential in-time time Riccati recursions. Third, on the CPU, DifEMPC lies in-between mpc. wwt.pyyorroee and tra jax, so tra jax should be preferred on the CPU as sequential Riccati recursions are better suited for CPU execution. However, on the GPU, Di FMPC is significantly faster than other solvers, with

---

Published as a conference paper at ICLR 2026
-104
6,193
Forward
0.8
4,394
4,460
I Backward
Time (ms)
3,373
0.6
,2,702
4.
1,446
1,900
1,326
1,909
1,828
0.4
930
954
219
322
0.2
Theseus mp trajax DiffMPC Theseus pp trajax DiffMPC (CPU)
(CPU) (CPU) (CPU)
(GPU) (GPU) (GPU) (GPU)
Figure 3: RL computation times on of the test problems. Error bars indicate 2o confidence
intervals. Each backward pass also includes one forward pass (to evaluate the inputs of Algorithm
times speedup over the fastest baseline for this problem. This speedup is likely due to 1MFC better leveraging parallelism over time in OCP. In Appendix [.I1 provide additional results other problems (including nonlinear attitude stabilization task), where we also observe significant speedups ranging from 4-7 times over jrajax (the fastest baseline) across all tested problems.
Warm-starting. Using Di FMPC's PCG routine for solving the KKT systems enables warm- starting both the forward and backward passes. Figure IO in the appendix reports speedups from warm-starting, computed as the ratio cold-warm comparing the RL computation times using cold
Dif and of DiffMPC with zero initial guesses provided PCG. For the PCG exit tolerance c= 10- that is used in this section's 's results, warm- warm-starting gives modest speedups of 4% for both the forward and backward passes. These speedups increase 11% and 9% for the forward and back- ward passes, respectively, if the tolerance is set to 10-4 Thus, we expect additional speedups for low tolerances and in applications where Di FMPC used to replan high frequencies.
Imitation Loss
4.2 TIMING RESULTS FOR IMITATION LEARNING
Tza Trajax
DIEIMPC
Next, we evaluate the method on an imitation learning task with nonlinear dynamics. Following the setup in (Amos et al. 2018), we use a cart-pole environment and cost parameters corresponding
0.5
50
100
150
expert imitation data collected by solving OCP. To this end, we minimize standard mean-square-error imitation learning loss, as de- fined in (3)) The goal of this experiment is to eval-
1.5
Model
0.5
uate end-to-end training speed on an imitation learn- ing task, with each training loop consisting of solving batch nonlinear optimization problems, computing the imitation loss, backpropagating gradients, and updating weights. Details are in Appendix B.2
50
100
150
Epochs
Figure 4: Losses over 200 epochs for
the pendulum cart-pole IL benchmark.
On the GPU, compare Di E EMPC against tra jax, as it is the fastest baseline from the previous section. reportss the training loss and model loss |0-00* where 6* are the true parameters of the policy used to generate the data. Di EMPC trains approximately 2x faster in wall-clock time while maintaining convergence, highlighting its efficiency for imitation learning.
APPLICATION TO DOMAIN RANDOMIZATION FOR DRIVING AT THE LIMITS
Finally, we demonstrate the practical utility of Di in learning robust controllers for driving at the limits of handling under model mismatch. Existing methods for drifting remain sensitive to modeling errors, as unstable dynamics can cause small errors to quickly amplify and destabilize the vehicle. While prior works have developed learning based and adaptive controllers (Davydov al., 2025 Djeumou et al. 2024), online adaptation alone may fail to recover control of a vehicle driving through varying road conditions due to limited actuation. Developing controllers that are robust to

---

Published as a conference paper at ICLR 2026
Baseline
RL training
Post RL
{E}}
Figure 5: Proposed RL training pipeline to robustify an MPC policy x² for drifting.
Baseline Learned X Baseline Spinout Learmed Spinout
Baseline
Learned
8 (rad)
100
Wyy (rad/s)
80
20
N
60
5
(rad)
40
1.5
20
(kNm)
0
200
400
600
800)
1000
60
20
40
Timestep
Pos. E (m)
Pos.
E (m)
Figure 6: Vehicle states (left) and position trajectories (right) when drifting a figure with puddles.
disturbances such as sudden friction loss from water puddles, and simplifying their tuning process that can be slow and expensive, is crucial for enabling safety-critical applications.
To this end, we use Di E FMMPC within a model-based RL framework for the task of robustly drifting trajectories using domain randomization. Here, we Di E FMPC with differentiable simulator to optimize the MPC problem parameters through backpropagation. We vary the simulator model & by adding water puddles on the road random locations that reduce available tire forces by modify- ing physical parameters such as tire friction coefficients, and starting the simulations from varying starting conditions zg. For each initial state-environment tuple (z) Et), we generate closed-loop rollouts of 200 steps by repeatedly solving the MPC problem, applying the control w and simulat- ing the evolution of the system given the sampled environments E These simulation environments use high-accuracy dynamics integrators and account for control delays, which would be difficult to do the MPC controller without increasing the complexity of OCP. The total reward aggregated over the batched rollouts, then backpropagated to learn the policy parameters 0, which consist of the cost weights and the tire friction parameters OCP. We found that using a large episode length (>> 100 time steps) and batch size (2 32) is necessary for robust training. We train the policy for 1000 steps with a batch size of 32, taking 14 hours on an NVIDIA GeForce RTX 4090. Further details in Appendix B.3
Changes parameters after training: MPC parameters pre- and post-training are Figure 12 in the appendix. Baseline weights were manually tuned using domain knowledge and tests on vehicle in nominal dry conditions. The learned policy has significantly decreased the rear tire friction coefficient in its prediction model (change of -13%) and decreased the cost term associated with sideslip angle eтrors in the objective function of OCP (change of -58%). These learned parameters are physically reasonable, but they would have been difficult obtain by hand, given the surprisingly asymmetric reduction in rear tire friction coefficients. Using these parameters enables the policy to trade off higher sideslip tracking errors for increased robustness to water puddles, and selecting lower engine torques, resulting in more robust drifting shown next.
Improved robustness in simulation: Figure 6 shows twenty roll-outs over randomized environ- ments for the baseline and learned policies, described in Appendix B.3 The learned policy is significantly more robust, succeeding in 100% of the trials compared to the 70% success rate of the baseline policy. The learned policy selects smaller steering angles and motor torques than the base- line. These actions result drifting with lower sideslip (the angle between the longitudinal axis and the velocity vector of the vehicle) and lower wheel speed, which gives additional buffers to avoid
8

---

Published as a conference paper at ICLR 2026
Water Puddle
Figure 7: Vehicle drifting through water puddle: top view (left) and center view (right). The Supra
robustly drifts despite variations in friction, which requires carefully selecting actions and sideslip.
(radsl
-410
Bascline
Learned
A
-415
20
or [mui]
Position
#
-420
Woarthaa
-425
-430
20
40
20
40
-290
-885
-280
-275
-270
Path distance (m)
Path distance (m)
Position (m)
Figure 8: Drifting donut with water puddle with Toyota Supra. Left: State trajectories of two runs with the baseline vs the learned policy. Right: top view trajectories of the runs.
saturating actuation limits and spinning out after drifting through water puddles. These changes result in significant robustness gains despite model mismatch.
The learned MPC policy is then deployed on a Toyota Supra drifting a donut trajectory through water puddles. Results are shown in and Although RL training is only conducted on figure-8 trajectories, the learned policy transfers successfully to drifting a circle without additional tuning, thanks to the inductive biases of MPC. In contrast to the baseline that consistently spins out due to the water puddle. the learned policy applies lower engine torques to reduce wheel speeds and maintain lower controlled sideslip angles / throughout the drifting manoeuver. Further results for drifting the figure 8 trajectory are in the appendix. Overall, these results show that training differentiable MPC policy via RL and domain randomization can produce robust, transferable controllers for driving at the limits of handling.
Results on a Toyota Supra:
DISCUSSION AND LIMITATIONS
While differentiable optimization tools often rely on iterative algorithms (such as gradient descent, SQP, and PCG), exploiting parallelism in the problem structure gives opportunities to leverage GPUs to efficiently solve such optimization problems. In this work, we exploit the dime-induced sparsity of optimal control problems to yield efficient differentiable optimization tool for model predictive control that outperforms existing tools when run on the GPU, even for modest batch sizes. This tool offers the strong inductive biases of model-based control in a package that better scales to the de- mands of data-driven methods, enabling integration of model- and learning-bass based approaches.
Limitations and future work: First, additional inequality constraints can be accounted for in OCP by penalizing them in the cost, and control bounds can be accounted for in the dynamics (e.g.. con- trol bounds are enforced in the simulator for RL Section [3. Handling such inequality constraints via augmented Lagrangian or interior-point methods (Howell et al., 2022, Bambade et al., 2024 Frey af. 2025 Zuliani et al. 2025) might lead to more reliable convergence and higher-quality solutions. However, reliably differentiating through such problems remains challenging, since gra- dients can discontinuous at the boundary of the constraints. Second, since Di f FMPC tailored to the GPU and implemented in JAX, it runs slower the CPU than the GPU. Rewriting the solver in C/C++ would give speedups over our JAX implementation, albeit other approaches using Riccati recursions might outperform Di f EMPC
the CPU. Fourth, DiffMPC does not explicitly support tuning solver hyperparameters such as the maximum number of iterations or the PCG tolerance, though its ability to in parallel over problem instances the GPU might help tune such hy-

---

Published as a conference paper at ICLR 2026
perparameters. Finally, poor initial guesses for the solutions and parameters of differentiable MPC tools can result in divergence of the solver and hinder the downstream training pipeline, motivating future work towards robust initializations for differentiable optimization pipelines.
Reproducibility statement. Code to reproduce results in Scction is available at
REFERENCES
E. Adabag, M. Atal, W. Gerard, and B. Plancher. MPCGPU: Real-time nonlinear model predictive control through preconditioned conjugate gradient on the GPU. Proc. IEEE Conf. on Robotics and Automation, 2024.
A. Agrawal, B. Amos, S. Barratt, S. Boyd, S. Diamond, and Z. Kolter. Differentiable convex opti- mization layers. In Conf. on Neural Information Processing Systems, 2019.
L. Amatucci, J. Sousa- Pinto, G. Turrisi, D. Orban, V. Barasuol, and C. Semini. Primal-dual iLQR for GPU-accelerated learning and control in legged robots. Available at battps://arxiln org/ abs/2506 07823 2025.
B. Amos and Z. Kolter. Optnet: Differentiable optimization layer in neural networks. In International conference on machine learning, pp. 136-145. PMLR, 2017.
B. Amos, D. J. Rodriguez, J. Sacks, B. Boots, and 7.. Kolter. Differentiable MPC for end-to-end planning and control. Conf. on Neural Information Processing Systems, 31, 2018.
S. Arold, P. Mahajan, D. Datta, I. Bunner, and K. S. Zarkias. leam2learn: A library for Meta- Learning research. August 2020. URL httthh/tp//aaxxx wwwp://..gggabb/////abaaa 12284
A. Bambade, F. Schramm, A. Taylor, and J. Carpentier. Leveraging augmented- Lagranggann tech- niques for differentiating over infeasible quadratic programs in machine learning. In Int. Conf. Learning Representations, 2024.
M. Bhardwaj, B. Boots, and M. Mukadam. Differentiable Gaussian process motion planning. In Proc. IEEE Conf. Robotics and Automation, 2020.
A. L. Bishop, J. Z. Zhang, S. Gurumurthy, K. Tracy, and Z. Manchester. ReLU-QP: A GPU- accelerated quadratic programming solver for model-predictive control. on Robotics and Automation, 2024.
Proc. IEEE Conf.
M. Blondel and V. Roulet. The elements of differentiable programming, 2024. URL https:
M. Blondel, Q. Berthet, M. Cuturi, R. Frostig, S. Hoyer, F. Llinares-López. F. Pedregosa, and J.- P. Vert. Efficient and modular implicit differentiation. Conf. on Neural Information Processing 2022.
Systems,
X. Bu and B. Plancher. Symmetric stair preconditioning of linear systems for parallel trajectory optimization. In Proc. IEEE Conf. on Robotics and Automation, 2024.
G. M. Chari, A. G. Kamath, P. Elango, and b. Acikmese, Fast Monte Carlo analysis for 6-DoF nowered-descent guidance via GPU-accelerated sequential convex programming. In AIAA Scitech Forum, 2024.
Y. Chen, D. Tse, P. Nobel, P. Goulart, and S. Boyd. CuClarabel: GPU acceleration for a conic optimization solver. Available a//ttpss:/arxiv. http://wwww..rrr//////2222.2..0/ 19027 2024.
M. Cummins, A. Padoan, K. Moffat, F. Dörfler, and J. Lygeros. DeePC-Hunt: Data-enabled predic- tive control hyperparameter tuning via differentiable optimization. In Learning for Dynamics & Control Conference, 2025.
A. Davydov, F. Djeumou, M. Greiff. M. Suminaka, M. Thompson. J. Subosits, and T. Lew. First, learn what you don't know: Active information gathering for driving at the limits of handling. IEEE Robotics and Automation Letters, 2025.
10

---

Published as a conference paper at ICLR 2026
DeepMind, I. Babuschkin, K. Baumli, A. Bell, S. Bhupatiraju, J. Bruce, P. Buchlovsky. D. Bud- den, T. Cai, A. Clark, I. Danihelka, A. Dedieu, C. Fantacci, J. Godwin, C. Jones, R. Hemsley, T. Hennigan, M. Hessel, S. Hou, S. Kapturowski, T. Keck, I. Kemaev, M. King, M. Kunesch, L.. Martens, H. Merzic, V. Mikulik, T. Norman, G. Papamakarios, J. Quan, R. Ring, F. Ruiz, A. Sanchez, I.. Sartran, R. Schneider, E. Sezener, S. Spencer, S. Srinivasan, M. Stanojevic, W. Stokowiec, L. Wang. G. Zhou, and F. Viola. The DeepMind JAX Ecosystem, 2020. URL
http:/
com/ google wwwp:/ooeooeeeeennooeeee deepmind
T. Deleu, T. Würfl, M. Samici, J. Cohen, and Y. Bengio. Torchmeta: A meta-lcarning library for pytorch, 2019. URL https:://aariiiiie org./vv.rrrraaae abs 1909..199.... 06576
F. Djeumou, T. Lew, N. Ding, M. Thompson, M. Suminaka, M. Greiff, and J. Subosits. One model to drift them all: Physics-informed conditional diffusion model for driving at the limits. In Annual Conference on Robot Learning. 2024.
M. Feng, Z. Frangella, and M. Pilanci. CRONOS:
Enhancing deep learning with scalable GPU accelerated convex neural networks. In Conf. on Neural Information Processing Systems, 2024.
Frey, K. Baumgartner, Frison, D. Reinhardt, J. Hoffmann, L. Fichtner, S. Gros, and M. Dichl. Differentiable nonlinear model predictive control. Available at https://arxiv.. http://axxxvv.../abb.ee 2505. 01353 2025.
R. Frostig, S. Sindhwani, and S. Tu. Trajax, 2021. URL trajax
J. Goh and C. Gerdes. Simultaneous stabilization and tracking of basic automobile drifting trajecto- ries. In IEEE Intelligent Vehicles Symposium, 2016.
S. Gould, B. Fernando, A. Cherian, P. Anderson, R. S. Cruz, and E. Guo. On differentiating pa- rameterized argmin and argmax problems with application to bi-level optimization. Available at 05447 2016.
https::/arxiv..rrg// htw.g///b///ll//
R. Grandia, F. Farshidian, E. Knoop, C. Schumacher, M. Hutter, and M. Bächer. DOC: Differentiable optimal control for retargeting motions onto legged robots. ACM Transactions on Graphics, 42 (4):1-14,uuly 2023.
S. Gros, M. Zanon, R. Quirynen, Bemporad, and M. Diehl. From linear to nonlinear MPC: bridging the gap via the real-time iteration. International Journal of Control, 93(1):62-88) 80, 2020.
T. A. Howell, Tracy, Le Cleac'h, and Z. Manchester. Calipso: A differentiable solver for trajectory optimization with conic and complementarity constraints. In Int. Symp. on Robotics Research, 2022.
S. H. Jeon, S. Hong, H. J. Lee, C. Khazoom, and S. Kim. Cusadi: A GPU parallelization framework for symbolic expressions and optimal control. IEEE Robotics and Automation Letters, 2024.
A. Jordana, S. Kleff, A. Meduri, J. Carpentier, N. Mansard, and L. Righetti. Structure-exploiting sequential quadratic programming for moeel-predictive control. IEEE Transactions on Robotics, 41:4960-499 2025.
X. Kang, s. Xu, J. Sarva, L. Liang, and H. Yang. Fast and certifiable trajectory optimization. In Workshop Algorithmic Foundations of Robotics, 2024.
Karkus, B. Ivanovic, S. Mamnor, and M. Pavone. Diffstack: A differentiable and modular control stack for autonomous vehicles. In Conf. Robot Learning, 2023.
P. Kidger. On Neural Differential Equations. PhD thesis, University of Oxford, 2021.
B. Landry, Z.. Manchester, and M. Pavone. A differentiable augmented lagrangian method for bilevel nonlinear optimization. arXiv preprint axxi 2019.
J. M. Lee. Introduction Smooth Manifolds. Springer New York, second edition, 2012.

---

Published as a conference paper at ICLR 2026
T. Lew, M. Greiff, F. Djeumou, M. Suminaka, M. Thompson, and J. Subosits. Risk- averse model predictive control for racing adverse conditions. Proc. IEEE Conf. on Robotics and Automa- fion, 2025.
A. Montoison and J.-B. Caillau, Modeling and optimization of control problems GPUs. Available at /ulttps://rrae arxiv.. brggabss/511..00 03932 2025.
J. Nocedal and S. J. Wright. Numerical Optimization. Springer New York, second edition, 2006.
L. Pineda, T. Fan, M. Monge, S. Venkataraman, P. Sodhi, R. T. Q. Chen, J. Ortiz, D. DeTone, A. Wang, S. Anderson, al. Theseus: A library for differentiable nonlinear optimization. Conf. Neural Information Processing Systems, 15:3801-3811 2022.
Ren, X. Feng. B. Liu, X. Pan, Y. Fu, L. Mai, and Y. Yang. TorchOpt: An efficient library for differentiable optimization. Journal of Machine Learning Research, 24(367):1-14, 2023.
A. Romero, E. Aljalbout, Y. Song, and D. Scaramuzza. Actor-critic model predictive control: Dif- ferentiable optimization meets reinforcement learning. arXiv preprint arXiv:2306.09833 2024.
M. Schubiger, Banjac, and J. Lygeros. GPU acceleration of ADMM for large-scale quadratic programming. Journal of Parallel and Distributed Computing, 144:55-61 2020.
S. Singh, J.-J. Slotine, and V. Sindhwani. Optimizing trajectories with closed-loop dynamic SQP. In Proc. IEEE Conf. on Robotics and Automation, 2022.
B. Stellato, G. Banjac. P. Goulart, A. Bemporad, and S. Boyd. OSQP: an operator splitting solver for quadratic programs. Mathematical Programming Computation, 12(4):637-672, 2020.
Svendenius. Tire Modeling and Friction Extimation. Doctoral thesis, Lund Institute of Technology, Lund University, 2007.
W. Wan, Z. Wang, Y. Wang, Z. Erickson, and D. Held. Difftori: Differentiable trajectory opti- mization for deep reinforcement and imitation learning. Conf. on Neural Information Processing Systems, 2024.
R. Zuliani, E. Balta, and J. Lygeros. Differentiable by design nonlinear optimization and its appli- cation to model predictive control. Available at https: // http/vxxvvvv...o/.. wwwpvlvv.rr/bb//255533 12692 2025.
12

---

Published as a conference paper at ICLR 2026
APPENDIX
A SOLVER: ADDITIONAL DETAILS
A.1 VECTOR-JACOBIAN PRODUCTS (VJPS) VS JACOBIAN-VECTOR PRODUCTS (JVPS)
From vector-Jacobian products (VJP) for computing gradients of scalar-valued functions of
solutions to optimization problems can be computed as
Ow T
OF
OOF
OF
aF dw
where
solves
00
00
Sw
00
(x++g
(n++g) x((+0) (n+tg)
where &w E (((++))(+++))) is symmetric, (3, X) E IR+ and E RR++, In contrast, computing
OF
JVPs of the form requires computing the full Jacobian 0: 39
RRxx,, which is the solution p
linear systems. Indeed, by (2) each sensitivity is obtained by solving
8e,
OF
OF
Fw
8A
00;
30
Thus, reverse mode differentiation via VJPs is preferred to forward mode differentiation via JVPs in many applications, such reinforcement learning and imitation learning.
A.2 PCG ALGORITHM
The Projected Conjugate Gradient (PCG) algorithm introduced in (Adabag et al. 2024) is used to solve the linear KKT systems DiFEMPC (see Algorithm B}. Note that y in (9) takes the form
7 = d + (Q, 4u So= S1....,
with &. A, at + B, + A Q,+ 1t+1 for all Also, lines 1, 2, 6, and 11 of Algorithm are parallelized over time, reducing computation times when executed on the GPU.
A.3 LINE SEARCH
After solving each QP, we use standard line search method (Nocedal & Wright 2006 Algorithm 18.3) described next. Below, we denote by - (a+ w=*) the solution to QP, which is evaluated (x. u). The objective of the line search is to select an appropriate step size a E (0, so the new solution (xr + a(x x), + a(u+ u)) is closer to an optimal solution to OCP.
The line search uses a merit function & defined as the weighted sum of the cost and constraints
(a,, u) = Σ (c (Ix) (w,) + p [I (T(+1, F4, 4))li)
(15)
where the penalty parameter 14 is set as in Nocedal Wright 2006 Equation 18.33 with = 0.5):
# Σ, (x)) (at x2) Vel (u.) Tu, ue)
(16)
0.5 0.5 E, [ff 2,, 4x]l1
The decrease condition for accepting step size a is (Nocedal Wright 2006 Equation 18.28)
Ap. := spx + adx, u + aAu) p(z, u) naD, for some 77 (0, 1) (we Equation 18.29)
(17)
0.4), with descent direction defined as (Nocedal & Wrightt 2006
Dp = Σ Ve (xx) (xx - xx) + Ve (4) (u, u.) 1nn1:ll(aaaa (f u.)l..
(18)
Merit function values p(z + aAr, + adv) evaluated in parallel over different pre-defined step sizes in decreasing order à == {1.0, 0.7, 0.3, 0.1, 0.013. The line search method is described in further details in Algorithm
13

---

Published as a conference paper at ICLR 2026
Algorithm PCG for solving SX y in (10) Adabag al. 2024).
Algorithm Linesearch for SQP.
Inputs: Previous solution = (x, u) for formu-
Inputs: 5,7, 2-
initial guess X, tolerance e
lating QP, solution = = (at aut to QP.
1: - SX
P 7 114411411
2: --1r
Dt 2, T1-1441
candidate step sizes à (1.0,0.7....)
3: p =
Evaluate merit function p( u)
Eq.
4: 1 p-rr FT
2: Evaluate penalty parameter μ Evaluate descent direction D₁
Eq. 16
5: while fj > cd
Eq.
6: y Sp
y S.
4: for É á do
in parallel
7: V P Y
5: Evaluate decrease condition Apa
Eq.
8:
11
6: a < min(á)
9: À X + ap
r r ay
7: for ä E à do
sequentially
11: i = Φ 1
b = 1
8: if Aipa < 0 then
T' T
9: a f-- ā
select largest step size
13:
3 1/ /
10:
Break
14:
p = f + 3p
11: Return: New solution (x + a(x - x), +
15:
((u+-u))
16: return: solution À to the system SA =Y
B RESULTS: ADDITIONAL DETAILS AND EXPERIMENTS
In this section, ~ (ū, Σ) denotes Gaussian random variable with mean and covariance matrix Σ, and y ~ U(aa, b]) denotes a uniform random variable in the interval [a, bj.
B. REINFORCEMENT LEARNING BENCHMARK
For the RL benchmark, we start by describing the solvers used and how they were modified to pro- duce a fair comparison of Theseus, mpc. pyt trajax and D Dif CMPC. We then consider a linear problem to facilitate ablations on the problem size and study the impact of warm starting on the PCG algorithm. Finally, we consider a nonlinear spacecraft example where we compare the computation times for tra jrajjax and DiPP
Setup. For this RL benchmark, we use an evaluation scheme simi- lar to the RL pipeline in Fig- 5 methods use compute gradients via implicit differentiation and use float64 precision. Timing con- ducted on a workstation with a 64-Core AMD Threadripper 3990X CPU and a NVIDIA GeForee RTX 3090 GPU rumning Ubuntu 22.04. For these evaluations on QP problems, mpc pytorch is constrained to 1 iLQR iteration, the line search is disabled, and flags are set so that it exits after the first iteration without detaching gra- dients. The original code is slightly modified to eliminate a serial list comprehension that causes the library to scale poorly when inequality constraints are disabled. Table[[ our modified version of mpc. pytorch to the base version on the first seed from problem 1, and shows that our modifications reduce the solve times of the forward pass and gradient computations. Since Theseus only supports unconstrained non-linear least-square optimization problems, the dynamics are rolled out in the objective function as done in (Wan et al., 2024). The damped least squares method is used and constrained to iteration of the dense Cholesky solver. Trajax uses the buib iLQR OCP solver, and is constrained to iLQR iteration and minimum line search step of 0.99 (we found that a minimum The tviqr method is used for the backward pass. Di E EEMMMC is also limited to QP solve and line search iteration, with à = {1}. The underlying PCG solver uses an exit tolerance of 10- 12 for both the forwards and backwards passes.
Table 1: Computation times (s) with mpc pytorch for Problem on the GPU.
Pass
Original Modified
Fwd Bwd
67.9
1.9
136.4
4.5
prevents any solution from being accepted).
QP problems. We consider the six problems defined in Table 2 The dynamics of each prob- lem defined F++1 Ax, But + b. The dynamics matrix is randomized according
14

---

Published as a conference paper at ICLR 2026
Forward Passs
Bockwerd Pazs
Speeday (56)
10
10-12
10-4 POG Tolezance
10-4
10
10-8 PCG Tolerance
10-4
Figure 10: RL with Di FMPP: Speedups from warm-starting SolveTime all Solvenimeeon for different PCG exit tolerances e, with +2 standard deviation intervals.
SolveTime,ad
to 1 with vec(AA) ~ (0, I), and eigenvalues are clipped to lie within the unit circle so that IA(A) E (0, 0.999. Similarly, we let BB) ~ NN, T), b (O, 0. 0.10-1)), and sample initial conditions as 20 (0, 257). The cost functions in OCP are quadratic functions G 2.0 (x) x Qr where Q is a diagonal matrix and 24.8 (w) |ul 2 for all t. The RL reward is defined as R(x, u)
-[|=11 + [|=l(²). The parameters 0 that are optimized 0 = diag(Q). For each of these problems. we compute statistics over ten independent runs per method, from Theseus the CPU). Timing results are in Table 3 The results of Problem 1 are il- lustrated in Figure 3. and are representative of performance across the tested problem instances.
observed little variation in computation times within each problem (apart
Table 2: Parameters in the RL benchmark: state dimension R2z control dimension Ta. MPC hori- zon T, RI. episodes length H, batch size B.
Warm-starting. We provide further results in Figure 10 to assess the benefits from warm- starting Di FMFC for different PCG exit tol- erances e E {10 10 10 12 Problem 1. Statistics are computed over 100 indepen- dent runs for each PCG exit tolerance. We ob- serve speedups for both the forward and back- ward passes. Speedups are more significant for lower PCG exit tolerances e. We note that tol- erances in the order
Problem
fg
nh
T
H
B
1
8
4
40
50
64
2
8
30
50
16
3
8
4
30
50
64
4
30
50
256
10-4 are reasonable for many applications, see the results in (Ad- abag al., 2024). To ensure fair comparisons against baselines, we used the lowest tolerance 10-12 in all other results in the paper, and antic- ipate that additional speedups compared to these baselines could be observed by selecting smaller exit tolerance
5
16
8
30
50
16
6
16
30
50
64
Accuracy computed gradients. We evaluate the accuracy of the gradients computed by DiffMPC against finite- difference approximations and report re- sults Figure These statistics are com- puted over 100 problem instances for each PCG exit tolerance. For this problem, we observe high degree of consistency be- tween Dif f FMPC and finite differences up PCG exit tolerance of 10-6, We use an exit tolerance of 10 for all other re- sults.
1.00
0.75
Cosine Similarity
0.50
0.25
0.00
-0.50
-0.75
1e-12 1e-10 1e-8
16-6 1e-4 1e-2
PCG Solver Tooeeance
Figure 9: Cosine similarity between computed gradi- ents and finite differencing across PCG exit tolerances.
15

---

Published as a conference paper at ICLR 2026
Table 3: Timing results on CPU and GPU across 6 problem instances with mean time and 2o (s).
Method
GPU
Pass
Problem
Problem
Problem
Problem 4
Problem
Problem
Theseus
x
Bwd
81.47 (34,50)
5.04 (0.46)
10.44 (3.28)
130.01 (2.94)
9.27 (3.70)
130.67 (5.73)
Theseus
x
Fwd
49.35 (70.65)
3.39 (0.18)
6.10 (2.18)
65.44 (63.67)
5.63 (2.45)
70.74 (85.68)
mpo, pytorch
X
Bwd
3.37 (0.07)
1.71 (0.03)
2.60 (0.07)
5.61 (0:08)
2.32 (0.04)
4.01 (0.07)
upe.pyLoren
X
Fwd
1.44 (0.03)
0.72 (0.01)
1.12 (0.03)
2.36 (0.03)
0.97 (0:01)
1,65 (0.02)
trajax
X
Bwd
1.90 (0.09)
0.34 (0.02)
1.42 (0.07)
5.95 (0.27)
0.94 (0.03)
3.89 (0.10)
Leajax
X
Fwd
0.93 (0.05)
0.17 (0.01)
0.70 (0.03)
2.96 (0.15)
0.45 (0.01)
1.91 (0.05)
DIIIMPC
X
Bwd
(1.07)
0.35 (0.10)
1.49 (0.44)
10.00 (3.71)
1,58 (0.30)
10.96 (2.97)
DIIIMPC
X
Fwd
1.33 (0.53)
0.16 (0.09)
0.71 (0.23)
5.09 (1.72)
0.74 (0.18)
5.49 (1.38)
Theseus /
Bwd
6.19 (0.11)
4.56 (0.14)
4.63 (0.14)
6.49 (0.03)
4.76 (0.10)
6.39 (0.04)
Theseus
Fwd
4.39 (0.14)
3.24 (0.17)
3.26 (0.05)
5.20 (0.02)
3.41 (0.12)
5.16 (0.04)
mpc. ooe.poae /
Bwd
4.46 (0.05)
3.33 (0.10)
3.40 (0.05)
3,98 (0.04)
3.33 (0.04)
3.43 (0.06)
mpe.pyLoren /
Fwd
1.91 (0.03)
1,45 (0.05)
1.45 (0.01)
1,67 (0.02)
1.45 (0.05)
1.47 (0.03)
tzajax Lzajax
/
Bwd
1.83 (0.26)
1,32 (0.19)
1.36 (0.18)
3.81 (0.63)
2.03 (0.04)
2.20 (0.04)
/
Fwd
0.95 (0.13)
0.70 (0.09)
0.71 (0.91)
1,93 (0.33)
1.05 (0.02)
1.13 (0.02)
DIfIMPC
/
Bwd
0.32 (0.10)
0.18 (0.06)
0.27 (0.08)
0.69 (0.16)
0.32 (0.08)
0.73 (0.16)
DI1IMPC
/
Fwd
0.22 (0.05)
0.11 (0.03)
0.18 (0.03)
0.49 (0.08)
0.20 (0.04)
0.45 (0.08)
Nonlinear attitude stabilization. We also consider a nonlinear attitude stabilization task, where drive the attitude rates of a rigid-body x = w E R (rad/s) to zero by actuating the torques u E R The nonlinear
Table 4: Compute times the nonlin- ear attitude stabilization problem.
Method
Pass
Compute time (ms)
continuous- time system dynamics are
trajax
Fwd.
310.6 (24.1)
trajax
Bwd.
505.0 (27.4)
J = W
(19)
DiFIMPC
Fwd.
39.8 (8.0)
where J > O is diagonal inertia matrix. We discretize the system using forward Euler scheme with a time step of At 0.1 We consider an MPC policy with prediction horizon T = 25 and costs defined as in QP with nominal time-invariant cost matrices Q = R 1. The learned parameters are defined as 0 (diag(Q) Q), diiag({)): and we train these parameters via gradient descent on the RL reward R(z, u) = (0.1|| + ||ul(() using a batch size of = 16. In each batch, we draw random initial conditions from W/ U[[[1, 1J3) and randomize the inertia matrix diag(J) Z( 2( 1) We compare the compute times on the backward and forward passes for this problem with t and D fMPC. Results reported in Table We note significant speedup (approximately 7.3x for the backward pass) when solving this problem using Di f fMPC C compared to trajax.
DifIMPC
Bwd.
69.3 (16.1)
B.2 IMITATION LEARNING BENCHMARK
For this task, we consider the cart-pole problem in (Amos et al.) 2018). with states x (I1, F2, 23, x24) Rd (m, m/s, rad, rad/s) and inputs u E (N). The model is parametrized with a length L, the cart mass me the pole mass mi, and the gravitational constant g. Its dynamics are
i F22
(20a)
42 my Lssn(za)) + myD (aa) cos(23)
(20b)
(M + mp cos*(
33 I4,
(20c)
41- = my Lin [33 x4 + m sin( (3)) +
(20d)
M m. cos2 (x:))
and we let m. = 1, m, 0.1, - 0.5, g 9.81, with M m. m. = 1.1. To generate expert data, we use DiffMPC in the form of OCP, with the quadratic objective in QP
Q = diag(1,2,11.. 1.5, 1), and R. = 0.05 Vt = 0,..., T.
(21)
Based on this expert policy, 32 different initial conditions 20 = (ø10, 220 Z30 koo) are sam- pled according to the uniform distributions Iio U[[-0.5, 0.5)), v2n 21( (((10..5 0.5, 0.5)) 230
16

---

Published as a conference paper at ICLR 2026
Table 5: Nominal vehicle model parameters and controller gains for the bascline MPC policy.
Qxe
Qsi
Qsi
Qus
Qus
Qei
Rai
Reg a
m
Tv
Pr
Cr
C,
Value
10
10-
500
20
300
10
10
1 1:239
1.209
1476
0.323
0.99
0.90
5-0000
223000
11.28
u([-T,,]] =]), and Zao ~ 1I). From each initial condition, an expert trajectory is gener- ated using Di DiffMPC with the costs in (2T). For imitation learning, we learn the cost parameters 0 = (Qu. Q22, Q33, Q41) and draw the initial parameters of the learned policy from a uniform dis- tribution (1, 1).. Training is conducted using batch size of 32, following Amos et al. (2018), by gradient descent using a learning rate of 10-2 on the mean-square-eree objective defined in (13). Both t jax and DifIMPC were limited to five SQP and iLQR iterations and are warm-started using the expert trajectory.
B.3 DRIFTING EXPERIMENTS
Vehicle model. For the drifting experiments, we consider a dynamic bicycle model (Lew et al. 2025) for both planning and simulation. We model tire forces using a coupled slip brush Fiala model (Svendenius] 2007). In this setting, the state of the system is defined by x = (r, v, 3, w,,, Aó, e, s) e RT, where (rad/s) is yaw rate, v (m/s) is longitudinal velocity, / (rad) is sideslip angle, wir (rad/s) is the average rear wheel speeds, Aø (rad) is a heading tracking error with respect to a reference, e lateral tracking error to the same reference, and (m) is the path distance traveled along the reference trajectory. The car is driven by the control input (6, T), where ó (rad) is the steering angle, and T (Nm) is the engine torque. The simulator discretizes the vehicle's 's dynamics using a high-accuracy Dormand- Prince method implemented in Di piffrax (Kidger (021), whereas the MPC model uses a simple trapezoidal scheme discretized At 0.1 sec. Box constraints on the control inputs are enforced in the simulator but omitted in the MPC controller so that robustness to actuator saturation is learned implicitly through training, and so that simpler unconstrained problems can be solved both during training and at runtime.
The vehicle dynamics are parameterized by the parameters (a, b, Lg, m. Two Lw, Cj, Cry Hf (r)) E R-10 where (a. b) define the location of the center of mass of the vehicle, m its mass, Iw the wheel radius, 12 is the moment of inertia about the yaw axis, Iw is the moment of inertia of wheel, and C, and μ4 denote the cornering stiffness and friction coefficients of the front and read wheels i E { r. respectively. Nominal vehicle parameters are given in Table
MPC. The cost function of the MPC policy defined with quadratic costs
(xr)))) = [ - xref.s) ( T((=== - Zref,e),
4 2.0 ( Rū,
(22)
where u.0 (i)) penalizes control rates ú, = (wt+1 ut)/At (this cost is implemented in the MPC by augmenting the state with the control input as (r + (z, u)) and redefining the control input as the control rate (u < ú)), and Fref is a reference trajectory computed using the method in (Goh & Gerdes 2016) with nominal vehicle parameters. Experiments involve drifting along the figure g trajectory in Figure/6land the donut trajectory in 8
Learnable parameters. The learnable parameters 0 of the MPC policy the cost weights for the states and control rates, the front and rear tire friction values, the front and rear cornering stiffness, and the rear wheels inertia:
0 (diag(Q) (Q), diag(I)), Hf, pe, Cj, Cry Iw) E R
(23)
RL training procedure. To learn a robust drifting policy, we define the RL reward as
R(x)= = (r- + de x882
(24)
where À = 0.3 and > = 50. This reward optimizes for non-zero side-slip angles (to ensure drifting behavior) and prioritizes the heading reference tracking. The RL batch size is set to B 32, and the episode length is set to H 200, with each step taking 20ms. We found that RL training without a term rewarding high sideslips 3 yields policies that drive robustly the reference path without drifting, highlighting the challenge of controlling a vehicle in an unstable drifting regime. To rescale the learned cost parameters that have different magnitudes, and ensure that they remain
17

---

Published as a conference paper at ICLR 2026
Table 6: Parameters used for domain randomization. On water puddles, tire friction coefficients drop to 0.6.
Mr
10 3G
10 CC
Iw
Epddele
Spuddii
range [0.94, 1.04] [0.85, 0.95]
[52, 56]
[200, 240]
[8, 14]
[185, 700]
[0, 5]
-1,1]
strictly positive, they are log- normalizzzd for training. Training conducted on the figure trajectory only. The reward in 244 is maximized via gradient ascent with a constant learning rate of 0.1.
Randomization: The parameters for each of the distributions defined in Table where represents the initial state along the reference trajectory in meters, puudie represents the length of the puddle, and Spuddle represents the relative distance between where the front and rear wheels enter the puddle. We note that puddles can be of irregular shapes and drifting involves controlling a vehicle sideways, so front wheels do not necessarily enter water puddles before the rear wheels.
32 environments are drawn from uniform
MPC: During training, single SQP iteration used per time step to match the real-time iteration scheme that is used during deployment (Gros al. 2020). The MPC uses horizon of T 35 timesteps. The rollout loop used for simulation accounts for control delays present the real appli- cation by introducing 20 ms delay the incoming control signal, corresponding to conservative estimate of the time needed to replan on the vehicle using MPC.
Low-level interpolation: On the vehicle, low-level interpolation scheme is used to select control inputs from the MPC plan to send to the actuators. This interpolation scheme is also accounted for in simulation for RL. The MPC stack deployed the vehicle is identical to the stack used in training with D f IMPC, except that it uses OSQP (Stellato et al., 2020) as the QP solver instead of the PCG routine.
Training dynamics and memory requirements. In Fig.
II we report the training loss across 3 seeds for the first 100 steps of the drifting MPC controller RL training ex- periment. These results were collected on a workstation with a NVIDIA GeForce RTX 3090 GPU using batch size of
0.5
Loys
32, where used 18GB of VRAM. These results show that despite noise in the training curves, the loss consistently stabilizes to minimum after around 40 minutes of training for these runs.
0.1
20
40
80
100
120
Time (Minutes)
Figure 11:
Wall-clock training loss curves across 3 seeds.
18

---

Published as a conference paper at ICLR 2026
(radls)
[mmig]
Bascline
Leared
-2
-400
Position N ((n)
# [rad]]
au [m/s]
-420
-440
6 (rad]
#KNNm]
-460
Waee Paus
100
100
Path distance (m)
Path distance (m)
Position E (m)
Figure 13: On-vehicle for drifting figure trajectory with water puddle in the first turn. Closed-loop response task with the baseline (red) and the learned controller (blue).
Additional simulation results. In addition to the simulation results reported in Section 5 provide the result of training with puddles in the environment. In Figure 12 show the relative change in the learned parameters with respect the nominal parameters in Table The more robust policy produced by the RL training uses lower tire friction values. Using these lower friction parameters has the effect of reducing the torques and wheel speeds as the planner as- sumes the tires have less grip than they actu- ally do nominal road conditions, resulting in more shallow drift. The learned policy also exhibits a 58% reduction in sideslip cost B. Re- ducing this cost term on sideslip enables the policy to drift with lower sideslip (which leads worse tracking error) for increased robust- ness to potential spinouts.
3.585
0.39%
Dynamir
0.11%
-4.54%
-13.38%
-12.5
-10.0
-7.5
-5.0
-2.5
0.0
change
7.38%
CLONS
0.44%
-0,468
4.6
-1.4%
-7.50%
Percent Percent-change change vi nominal
Additional hardware results: drifting the figure 8. For completeness, in Figure 13 we report additional on-vehicle results for drifting the figure 8 trajectory in the presence of water puddle the first turn. In these experiments, the baseline spins out in the first turn, whereas the controller using the parameters learned using Di EMPC completes the maneuver. However, we were unfortunately only able to this experiment once for each method due to hardware limita- tions, For this reason, we refrain from drawing strong conclusions from these results.
Figure 12: Change in MPC policy parameters af- ter learning by domain randomization that in- cludes water puddles.
19


Reviews:
[{"review_id": "Lza38FQrrx", "reviewer": "Reviewer_weUS", "summary": "The paper introduces DiffMPC, a GPU-accelerated, differentiable model predictive control (MPC) solver built in JAX. The core idea is to solve and differentiate through optimal control problems (OCPs) using an SQP loop whose linear KKT systems are handled by a preconditioned conjugate gradient (PCG) routine with a symmetric stair (block-tridiagonal) preconditioner, exposing parallelism over time for both forward and backward passes. Warm-starting and reusing forward KKT factorizations in the backward VJP further reduce cost. Empirically, DiffMPC achieves 4–7× speedups over Trajax/mpc.pytorch/Theseus on GPU for RL/IL benchmarks, trains ~2× faster than Trajax on a nonlinear imitation-learning cart-pole, and supports an RL domain-randomization pipeline that improves robustness, with successful real-vehicle transfers.", "questions": "1. Can you report gradient-accuracy diagnostics, e.g., cosine similarity vs finite-difference or “exact” KKT-curvature gradients, on small OCPs, and show their effect on IL/RL convergence? This would directly test the stated trade-off in Sec. 3.4.\n\n2. Could you include an experiment with explicit inequality constraints (e.g., torque/steering bounds) solved inside DiffMPC via an augmented-Lagrangian or interior-point variant, comparing robustness and speed to CPU solvers? Even a limited prototype would evidence extensibility.\n\n3. For the drifting study, can you provide wall-clock training curves, GPU memory use, and ablations over batch size, horizon, and PCG tolerance, plus a sensitivity to differentiable vs non-differentiable simulator components? This would help others scope hardware needs and replicate behavior.", "limitations": "", "rating": 6, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "1. The PCG with symmetric stair preconditioning cleanly leverages the OCP’s block-tridiagonal structure; both forward (solve) and backward (VJP) reuse the same KKT structure and benefit from warm-starts. The data-flow diagram (Fig. 2) and derivations (Eqs. 5–11) are clear. \n\n2. Across RL timing benchmarks, DiffMPC on GPU is ~4× faster than the best baseline for the shown problem and 4–7× across others. For IL (cart-pole), training progress per wall-clock roughly doubles vs Trajax. \n\n3. The RL+domain-randomization pipeline learns cost and tire parameters that eliminate spinouts in simulation (70% to 100% success) and transfer to a real Toyota Supra drifting donuts through puddles, illustrating robustness and policy generalization from differentiable MPC.\n\n4. The paper documents solver choices including line search schedule, tolerances, and reports warm-start gains, explains baseline configurations.", "weaknesses": "1. RL timings disable line search and cap all solvers to a single iteration on convex QPs. mpc.pytorch is also modified to remove a serial list comp. While justified for timing, this setting may favor DiffMPC’s parallel linear algebra over sequential Riccati recursions. A complementary benchmark with full nonconvex solves would strengthen claims.\n\n2. Warm-start gains are modest at strict tolerances (depending on $\\epsilon$), and CPU performance is acknowledged to be worse. A more systematic analysis of the relation between batch size/horizon/tolerance and speed/accuracy/memory would clarify operational regimes.\n\n3. Control bounds and other inequalities are handled outside OCP (e.g., in simulator) or via penalties, and the authors note future work for AL/IPM approaches. The absence of constrained OCP experiments limits conclusions for tasks where active sets matter.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "UyBxcGKIPP", "reviewer": "Reviewer_cUhS", "summary": "This paper introduces DiffMPC, a GPU-accelerated differentiable optimization solver for model predictive control (MPC) written in Jax. DiffMPC uses sequential quadratic programming with a line search and preconditioned conjugate gradient (PCG) with tridiagonal preconditioning to exploit the structure of their optimal control problem (OCP) for efficient GPU parallelization. Based on their formulation, DiffMPC benefits from warm-starting for both the forward and backward passes. Experimental results against existing solutions for GPU-accelerated differentiable MPC demonstrate that DiffMPC substantially benefits from GPU acceleration compared to baselines. DiffMPC is also demonstrated for real-world vehicle control.", "questions": "L404: Writing that DiffMPC is used within reinforcement learning is a little confusing. This makes it seem like this experiment is doing something similar to DiffTORI (Wan et al., 2024), which uses Theseus for differentiable trajectory optimization within a model-based RL approach with a learned world model. Based on my understanding, Section 5 is not doing this, but just directly using DiffMPC with a given differentiable model? \n\nL484: How sensitive is DiffMPC to the initial guesses to PCG? How much tuning was done?", "limitations": "", "rating": 8, "confidence": 3, "soundness": 3, "presentation": 4, "contribution": 3, "strengths": "- The paper is extremely well written and easy to follow. The authors provide comprehensive discussion on prior work in differentiable optimization and clearly explain their approach for differentiable MPC. \n\n- DiffMPC is 2-7x faster than Trajax, a comparable Jax-based differentiable MPC library, and two PyTorch-based differentiable MPC libraries, Mpc.pytorch and and Theseus. Surprisingly, the authors also show in Figure 3 that Mpc.pytorch and Theseus obtain similar runtimes when running on both CPU and GPU, so their implementations do not benefit from GPU-acceleration, while DiffMPC does.\n\n- The authors thoroughly explain the limitations of the proposed DiffMPC approach in Section 6. It is great to see this upfront, and the wider community may benefit when trying to build on the provided open source implementation. Based on a brief look at the Github repository, the code also appears to be well organized and easy to understand. \n\n- DiffMPC is deployed for real-world control of a vehicle drifting through water puddles, to showcase practical use of the approach.", "weaknesses": "- DiffMPC does not directly handle boundary conditions.\n\n- DiffMPC is slower on CPU than GPU compared to existing solutions, since DiffMPC avoids sequential Riccati recursions to better leverage GPU parallelism. \n\n- There is no evaluation on the quality of the gradients computed by DiffMPC. Some analysis comparing between DiffMPC and finite difference gradients would be helpful.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "BIqJYgHv13", "reviewer": "Reviewer_4NTm", "summary": "The paper presents a solver for Model Predictive Control (MPC) which is optimized for running on a GPU. The optimization tool called DiffMPC is differentiable and can be integrated in RL or imitation learning tasks. The method uses line search, warm start of both forward and backward pass, and parallelization over time steps to improve efficiency on the GPU. Experiments show that it runs faster on the GPU than other MPC solvers, and can be used effectively for RL and imitation learning tasks, including a simulation of driving in new domains.", "questions": "1. How much do the solver outputs (the optimized action u etc) in the RL experiment differ? I.e., does the DiffMPC solver achieve the same performance in one iteration as other solvers, or can the modifications lead to suboptimal results?\n2. In Figure 4, it is not visible that there is a 2x speedup; the loss of DiffMPC over time looks the same as trajax. Where is the 2x speedup shown?\n3. Why is line search disabled in the RL experiment? Is it not needed when the problem is convex? It seems to be a core part of the method. Is it used for imitation learning or the other experiment?", "limitations": "", "rating": 8, "confidence": 3, "soundness": 3, "presentation": 4, "contribution": 3, "strengths": "1. The method is tested in randomized environments as well as real applications, and the results in Figure 3 and Table 3 in the appendix show that it consistently outperforms the other methods.\n2. There are some ablations of individual aspects of the method, such as the warm start, which is convincing.\n3. The paper motivates the approach well and puts it into context with prior work, pointing out the shortcomings of GPU acceleration. It provides a good background section on differentiable control. It is convincing that this method can improve the integration of learning and optimization.\n4. The limitations are described transparently.", "weaknesses": "1. One limitation seems to be that only equality constraints are supported. This seems to impact comparability to the baselines (e.g. the appendix states that mpc.pytorch performance suffers when inequality constraints are disabled, which was tackled with some modifications to the code.)\n2. Only the synthetic randomized experiments compare the performance between all optimizers. In the imitation learning experiment, only trajax is compared, and in the driving-application, no other optimizer is tested.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Oral)