Reinforcement Learning for Autonomous Driving

Part 2: the research frontier

Maximilian Igl, NVIDIA

Overview

  • Overview
  • Semantic space
  • Traffic modeling
  • End-to-end policies
  • Takeaways

Why is closed-loop RL not yet the default for driving?

RL can greatly improve performance.

The Part 1 slide titled Experimental Evidence: a bar chart of laundry-folding throughput where RL on the robot's own experience roughly doubles the best supervised policy, a table where RoaD fine-tuning on AV NuRec beats continued behaviour cloning, and a WOSAC leaderboard table where a 7M-parameter model with closed-loop fine-tuning beats a 102M one trained open loop.

See motivation and evidence from Part 1.

But challenging to get right:

  • Reward design. Difficult to capture human driving and trade-offs in decision making.
  • Cost. Rendering and model inference.
  • Sim-to-real gap.
    • Appearance
    • Traffic behaviour
    • Physics, etc..
  • Imitation-to-RL gap.
    • No value function from pretraining
    • Whole trajectories out, only the first step executed

What is different today?

Breakthroughs in rendering technology.

Reconstructed worlds render the log from viewpoints it never had 20222023202420252026 3D Gaussian splatting dynamic urban scenes policies trained inside feed-forward, 1.5 s per log UniSim (NeRF) HUGSIM,NeuroNCAP RAD,NuRec Instant NuRec,World Engine Generated worlds video conditioned on the policy’s actions 20222023202420252026 video world model action-conditioned, open multi-view, foundation scale real time, policy in the loop GAIA-1 Vista GAIA-2,Cosmos,ReSim OmniDreams

Rendering technologies are now mature, realistic and fast enough to make RL training in them feasible.

Outline through Part II

Discussing the various challenges on our way to training a VLA policy.

Semantic space Traffic modeling End-to-end policies Reward design Traffic control Realism and diversity Simulation cost Trajectory actions Rendering validity Rewarding reasoning e.g. CaRL · BC-SAC · GigaFlow ·Spiced self-play e.g. CAT-K · RLFTSim e.g. Alpamayo-R1 · ReCogDrive · Gigapixel ·RoaD · PlannerRFT · RAD

Semantic space

  • Overview
  • Semantic space
  • Traffic modeling
  • End-to-end policies
  • Takeaways

Semantic space simulation is cheap, so RL from scratch is feasible

  • Simulator: Kinematic model that steps millions of agents per second
  • Actions: Low-level control or short trajectories
  • State: Agent boxes, map polylines, the route.
  • Policies: Small and trained from scratch

One agent’s observation: the ego at the centre, nearby agents as boxes, road points as dots.

Problem: Setting the reward is full of (unintended) trade-offs

Objective Measured by
Correctness collision, off-road, red light, right-of-way checks
Progress route completion, time to goal
Comfortable acceleration, jerk and yaw
Human-likeness e.g. distance to a human log or distribution matching
Considerate the cost imposed on others; needs partners that react
km per collision 0.010.11101001,00010,000100,0001,000,000 US drivers, 50 to 60 US drivers, 16 to 17 drunk US driver, 16 to 17 BC-SAC: never drives, ∞ MindDrive 2026, 1 km route LeTS-Drive 2019 CaRL 2025 in nuPlan, 150 m scenario HR-PPO 2024, crash = standing still 2,000× crash beats standing still: Roach, CaRL in CARLA, Kendall 2019, Implicit Affordances

Kilometres per collision at which a reward is indifferent between crashing and arriving.

Different approaches to reward design

It is better to define the outcome than the behavior.

Recipe Reward per step, one representative form The terms Papers
Shaped toward a reference planner

\[r_t = 1 - \frac{\lvert v_t - v^*_t \rvert}{v_{\max}} - \lambda_d\, d_t - \lambda_\theta\, \lvert \Delta\theta_t \rvert - \lambda_a\, \lvert \Delta a_t \rvert\]

−1 and stop on an infraction

  • \(v^*_t\): target speed set by the rules
  • \(d_t\): distance to the lane centre
  • \(\Delta\theta_t\): heading error to the lane
  • \(\Delta a_t\): change in action, for comfort
e.g. Implicit Affordances, Roach, World on Rails, Think2Drive
Progress, gated by termination

\[r_t = RC_t \prod_i p_{t,i}\]

infractions end the episode

  • \(RC_t\): route completion gained this step
  • \(p_{t,i}\): soft factors in \([0, 1]\): comfort, time to collision, lane keeping
  • the same shape as the driving score and PDMS
e.g. Kendall, CaRL, CLEAR, MindDrive
Safety only, imitation drives

\[r_t = \min(d^{\mathrm{coll}}_t - 1, 0) + \mathrm{clip}(-1 - d^{\mathrm{edge}}_t, -2, 0)\]

plus an imitation term in the loss

  • \(d^{\mathrm{coll}}_t\): distance to the nearest other box, in metres
  • \(d^{\mathrm{edge}}_t\): distance past the road edge
  • imitation term: log-likelihood of the expert action on logged states
e.g. BC-SAC, HR-PPO, RAD

Different approaches to mixing in human-likeness

Mechanism Term Papers
Imitation term in the loss \[\mathcal L = \mathcal L_{\text{RL}} \;{\color{#2f6f3e} -\; \lambda\, \mathbb E_{(s_h, a_h)\sim \mathcal D}\big[\log \pi_\theta(a_h \mid s_h)\big]}\] e.g. BC-SAC, RAD
KL to a BC-trained reference \[\mathcal L = \mathcal L_{\text{RL}} \;{\color{#2f6f3e} +\; \lambda\, \mathbb E_{s\sim \rho_{\pi_\theta}}\big[D_{\mathrm{KL}}\big(\pi_{\text{BC}}(\cdot \mid s)\,\big\|\,\pi_\theta(\cdot \mid s)\big)\big]}\] e.g. HR-PPO, spiced self-play, SPACeR
Distance to log in reward \[r(\tau) = r_{\text{rules}}(\tau) \;{\color{#2f6f3e} -\; \lambda\, d(\tau, \tau_h)}\] e.g. Alpamayo-R1, TrajHF

Examples: Evidence for simpler rewards plus scale

Bar chart of failure rates for BC, MGAIL and BC-SAC across six difficulty buckets from the hardest 1 percent to the 50 to 60 percent bucket. BC-SAC is lowest in every bucket; on the hardest 1 percent it is 2.59 percent against 4.21 for MGAIL and 5.79 for BC, and the gap narrows as scenes get easier.

Failure rate by scene difficulty. The gain from RL is largest where the demonstrations are rarest.

BC-SAC. One actor objective, imitation added to SAC:

\[\max_\pi\; \mathbb{E}_{s,a\sim\pi}\big[Q(s,a) + \mathcal{H}(\pi(\cdot\mid s))\big] + \lambda\, \mathbb{E}_{s,a\sim\mathcal{D}}\big[\log \pi(a\mid s)\big]\]

\[R = \min(d_{\text{coll}} - 1,\, 0) + \mathrm{clip}(-1 - d_{\text{edge}},\, -2,\, 0)\]

  • The reward has two safety terms and no progress term.
  • Trained on the hardest 10% of 100k miles.

Left: CaRL's reward, route completion times a product of penalties for collision, off-road, time to collision, comfort and lane distance, minus a terminal penalty. Right: driving score against mini-batch size on a log axis; the simple reward rises from 21 to 64 as the batch grows from 256 to 16,384, the prior complex reward falls from 34 to 0.

Route completion times infraction penalties.

CaRL. Plain PPO, no human data, one reward:

\[r_t = RC_t \prod_i p_{t,i} - T\]

  • \(RC_t\) route completion this step, \(p_{t,i} \in [0,1]\) soft penalties, \(T\) a terminal penalty. A collision ends the episode.
  • Specifies outcome and not behavior.
  • Reward prevents exploits and local optima.

Problem: The ego adapts to whoever drives the other cars

Traffic Model What breaks Used by
Log replay Many “false positives” (avoidable collisions). e.g. BC-SAC; nuPlan non-reactive; the uncontrolled agents in GPUDrive and PufferDrive
Rule-based Very predictable, ego overfits (e.g. becomes bully). e.g. CaRL, Roach, Implicit Affordances; Waymax ships IDM agents
Self-play Conventions that are effective, but alien. e.g. GigaFlow, HR-PPO, spiced self-play, Gigapixel
Learned traffic model Costly and ego can still overfit. evaluation only so far, e.g. Hagedorn et al. 2025, BehaviorBench

[BC-SAC] Lu et al. Imitation is not enough: robustifying imitation with reinforcement learning for challenging driving scenarios, 2023

[nuPlan] Caesar et al. nuPlan: a closed-loop ML-based planning benchmark for autonomous vehicles, 2021

[GPUDrive] Kazemkhani et al. GPUDrive: data-driven, multi-agent driving simulation at 1 million FPS, 2025

[PufferDrive] Cornelisse et al. PufferDrive: a fast and friendly driving simulator for training and evaluating RL agents, 2025

[CaRL] Jaeger et al. CaRL: learning scalable planning policies with simple rewards, 2025

[Roach] Zhang et al. End-to-end urban driving by imitating a reinforcement learning coach, 2021

[Implicit Affordances] Toromanoff et al. End-to-end model-free reinforcement learning for urban driving using implicit affordances, 2020

[Waymax] Gulino et al. Waymax: an accelerated, data-driven simulator for large-scale autonomous driving research, 2023

[GigaFlow] Cusumano-Towner et al. Robust autonomy emerges from self-play, 2025

[HR-PPO] Cornelisse and Vinitsky. Human-compatible driving partners through data-regularized self-play reinforcement learning, 2024

[Spiced self-play] Cornelisse et al. Human-like autonomy emerges from self-play and a pinch of human data, 2026

[Gigapixel] Rowe et al. Scaling self-play for end-to-end driving, 2026

Hagedorn et al. When planners meet reality: how learned, reactive traffic agents shift nuPlan benchmarks, 2025

[BehaviorBench] Distelzweig et al. Beyond self-play and scale: a behavior benchmark for generalization in autonomous driving, 2026

Examples: Making self-play robust and human like

Panel a: three benchmarks, CARLA, nuPlan and Waymax, each with a bar chart where prior benchmark-specific state of the art is grey and one zero-shot GigaFlow policy, in blue, is higher on all three. Panel b: a log-scale bar of simulated kilometres, existing datasets under one million, GigaFlow at 1.6 billion.

One 6M-parameter self-play policy, no human data, 1.6 billion km.

GigaFlow. Self-play with randomised reward weights per agent.

\[\begin{aligned} R &= R_{\mathrm{goal}} + \textstyle\sum_{k} \alpha_k R_k \\ \alpha_k &\sim U(\cdot) \text{ per agent and episode}, \qquad \pi(a \mid o, \alpha) \end{aligned}\]

\(k\): collision, off-road, comfort, lane, reverse and stop line.

Safe task completion against human demonstration data on a log axis. Plain self-play RL at zero human data scores 0.979; regularised self-play with about 30 minutes of human data scores 0.994, marked with a star; SMART trained by imitation on 52 days of human data scores 0.830. Arrows point from both baselines to the star.

Safe task completion against human data used. Thirty minutes as an anchor beats imitation on 52 days.

Spiced self-play. Mix self-play with thirty minutes of human logs.

\[\begin{aligned} \phi &= \arg\min_\phi \textstyle\sum_{(o, a) \in \mathcal{D}_{30\,\mathrm{min}}} -\log \tau_\phi(a \mid o) \\ \mathcal{L}(\theta) &= \mathcal{L}_{\mathrm{PPO}}(\theta) + \lambda\, \mathbb{E}_{o \sim \rho_{\pi_\theta}}\!\left[ D_{\mathrm{KL}}\!\left(\tau_\phi(\cdot \mid o) \,\|\, \pi_\theta(\cdot \mid o)\right) \right] \end{aligned}\]

Train anchor \(\tau_\phi\) on thirty minutes of human logs, then freeze it.
Very simple rewards: \(+1\) at the goal, \(-1\) on collision or off-road.

Traffic modeling

  • Overview
  • Semantic space
  • Traffic modeling
  • End-to-end policies
  • Takeaways

Problem: A traffic model has to be realistic and diverse at once

The Waymo Open Sim Agents Challenge is THE (only) benchmark for traffic models.
It rewards agents for matching the distribution of the logged data.

Roll out Histogram each feature Realism meta-metric 1 s of history, then 32 rollouts of 8 s logged trajectory is scored by its likelihood under histograms logged future 32 rollouts histogram over time and rollouts the human speed gap to the nearest car time to collision also acceleration, heading rate, collision, road edge, off-road average over agents, scenes and the 9 features ≈ 0.78

[WOSAC] Montali et al. The Waymo Open Sim Agents Challenge, 2023

Approaches have become more closed-loop over time

202420252025 to 2026 Imitation, open loop Closed-loop supervised fine-tuning Closed-loop RL fine-tuning Predict the next human token Recovery action as oracle, requires to stay close to the log during rollouts Construct a reward for learning the distribution, e.g. through a reference model or a statistics-based reward Signal human data Signal human data Signal reward Trains on logged states Trains on its own states, kept near the log Trains on its own states SMART CAT-K · RoaD SMART-R1 · RLFTSim · SPACeR

Examples: Two approaches for training diversity in closed loop

not in the top-K in the top-K closest to the human log human log tt+1t+2 executed: the top-Ktoken closest to the log recovery target, supervised WOSAC 2024 leaderboard, realism SMART-tiny + CAT-K, 7M SMART-large, 102M KiGRAS SMART-tiny, 7M FDriver-tiny SMART 0.7702 0.7614 0.7597 0.7591 0.7584 0.7511 0.74 0.77 axis clipped

Execute the top-\(K\) token nearest the log; supervise the token nearest the log. Fine-tuned this way, the 7M model tops the 102M one.

CAT-K. Use recovery to the log as oracle in DAgger-style loss:

\[\text{execute}\; \arg\min_{a \in \text{top-}K} d_{\log}(a), \qquad \text{supervise}\; \arg\min_{a \in \mathcal{A}} d_{\log}(a)\]

  • \(d_{\log}(a)\) distance from the logged next state after token \(a\).
  • Motivation: Supervised training, but from closed-loop states.
  • CAT-K (Closest among Top-K) rollouts to stay close to the log and keep log-oracle a valid target.
the group without i rollout i with i without i human’s value histogram of one feature, e.g. speed reward for i: how much its presence raises the likelihood of the human’s value

Leave-one-out: rollout \(i\) is rewarded for making the group more human.

RLFTSim. A reward on a group of \(G\) rollouts, via REINFORCE:

\[A_i = \frac{1}{G}\sum_{j=1}^{G} m(\mathcal{G}_{-j}) - m(\mathcal{G}_{-i}), \qquad \textstyle\sum_i A_i = 0\]

  • \(m(\mathcal{G}_{-i})\) WOSAC realism of the group without rollout \(i\).
  • Additional KL regularisation to a reference model to keep the model human-like.

End-to-end policies

  • Overview
  • Semantic space
  • Traffic modeling
  • End-to-end policies
  • Takeaways

Alpamayo-R1: An example for a modern end-to-end policy

cameras, past frames “in 400 ft, turn right” navigation, commands ego history Cosmos-Reason VLM imitation, then SFT, then RL Reasoning trace “Pedestrian on the right is about to cross, so I slow down and stop.” text, ~40 tokens Meta-actions slow downstopkeep lane discrete, longitudinal × lateral Trajectory as tokens in training a₁κ₁a₂κ₂a₃κ₃a₄κ₄ … 64 waypoints, 128 tokens exact log π · 222 ms Trajectory by flow matching at inference, conditioned on the trace 5 steps no density · 9 ms

Problem: Sensor simulation is too expensive for RL from scratch

We need to fine-tune from a pre-trained policy, and be as data efficient as possible.

Synthetic 3D scenes

Neural reconstruction

≈ 100k–1M steps/s ≈ 100 frames/s (480p) ≈ 20 frames/s (1080p) PufferDrive, GPUDrive; all agents, one GPU CARLA camera capture, one GPU NuRec render, one GPU, own estimate Realism and cost A trillion steps on eight GPUs, world step only: ≈ 1.5 days in semantic state, ≈ 400 years rendered at 1080p

Three approaches for fine-tuning E2E models in close(ish)-loop

Method World interactions Learning signal Problems Examples
Open-loop RL None Reward on open-loop rollout Non-reactive, still on logged states. e.g. ReCogDrive, Alpamayo-R1
Closed-loop SFT Few A target from an oracle/teacher (e.g. OPD) Needs an oracle e.g. CAT-K, RoaD (log); Roach, Gigapixel (teacher)
Closed-loop RL Many, for exploration Reward on closed-loop rollout Expensive e.g. RAD, PlannerRFT, CLEAR

Examples: Two efficient ways for close(ish) loop training

logged frame rollout plans R1 R2 R3 R4 group mean

Multiple plans from a logged frame, rewards against the logged future.

Open-loop RL. Score plans on logged states.

  • Start from a logged state and propose multiple plans.
  • Score each plan against the logged future (no replanning!).
  • Train plans with GRPO.
  • e.g. ReCogDrive, Alpamayo-R1, AutoVLA, LCDrive and TrajHF.
  • Trains the AR plan rollout in “closed loop”.

Roach's overview figure. Top, the driver, on green: a camera image from CARLA goes into an IL agent that outputs steering and pedal actions. Bottom, the expert, on red: the simulation ground truth, a bird's-eye-view semantic map, goes into an RL coach whose actions are greyed out. An arrow labelled strong supervisions runs from the RL coach up to the IL agent.

Distill BEV RL teacher into camera student.

Closed-loop SFT (DAgger) from an RL teacher. Roach’s recipe:

  • Train RL teacher (PPO) on BEV.
  • Train student with DAgger from RL teacher.
  • Distillation also uses latents and values as auxiliary targets.
  • Gigapixel (2026) scales this: self-play teacher, rendered-pixel student, perception adapter to real sensors.

Examples: Closed-loop RL of a pretrained sensor policy

Diagram of RAD's post-training. Left, N parallel workers each roll out a frozen AD policy inside a 3D Gaussian splatting scene and record transitions. Middle, two data sources: the 3DGS rollout data and selected human driving demonstrations. Right, both feed the trainable AD policy, the rollouts through RL training steps and the demonstrations through imitation training steps.

Combining PPO training on 3968 scenes with continuous IL training.

RAD. Fine-tunes an E2E policy with PPO.

  • Camera policy pretrained on 2,000h.
  • Fine-tuned with PPO on 3,968 reconstructed 3DGS scenes.
  • Collision ratio 0.270 → 0.089 on 337 held-out scenes.
  • Co-training with imitation on human demonstrations.
  • Constructs dense rewards.
AlpaGym AlpaSim

Unfortunately not the official logos.

Some soon-to-be released papers from our group on fine-tuning Alpamayo in AlpaSim.

  • Tricks for fine-tuning Alpamayo with open-loop RL.
  • Using an RL teacher as Oracle for DAgger-style closed-loop SFT.
  • Large-scale training with AlpaGym.

AlpaSim and AlpaGym make Closed-loop RL more accessible

Flexible outputs of AlpaSim: Map, NuRec (3DGS), and the OmniDreams world model.

AlpaSim. Performant, modular and open-source closed-loop simulator for E2E driving.

  • Modular: driver, renderer, traffic model, etc. can be changed.
  • Optimized: parallel and memory optimized, keeping GPUs hot.
  • With 3DGS (NuRec or MTGS) or world models (OmniDreams)
  • We are launching a challenge and leaderboard (Kashyap will likely say more)
steps per GPU-hour 0 5k 10k 15k ≈ 4.3 steps / s per GPU 15,288 15,727 15,884 15,837 64 GPUs128 GPUs256 GPUs512 GPUs 8 nodes16 nodes32 nodes64 nodes

Steps per GPU-hour on 8 to 64 nodes: flat per GPU, so linear in GPUs.

AlpaGym. Closed-loop RL on top of AlpaSim and Cosmos-RL.

  • Achieves around 80% GPU utilization.
  • Throughput scales linearly to 512 GPUs
  • Around 15.8k env steps per GPU-hour (rollout + traininer!)
  • Performant version will be open-sourced soon (1-2 months)!

Open problems for closed-loop RL and their workarounds

Gap Problem Workaround
RL with trajectory outputs IL policies generate planned trajectories, but only ~0.1s are executed, leading to very sparse training signals. Mix in imitation or open-loop RL, which trains the whole plan
Critic initialization PPO needs a critic \(V^{\pi_\theta}\), which pre-training doesn’t provide. Training with a random critic destroys the policy. Initialize \(V^{\pi_\theta}\) from Monte Carlo rollouts from the data or pre-trained policy.
Sim2Real gaps of the renderer 3DGS is only valid on a corridor around the logged trajectory. World-models can break down in the tail (e.g. just before collisions). End the episode when the ego leaves the corridor

RL on reasoning traces uses the open-loop RL

Alpamayo-R1's RL post-training. Left, two reward sources: verifiable rewards for physical safety and traffic rules, and teacher-model feedback for reasoning grading, semantic safety and causality assessment. Middle, a reward that verifies and aggregates the information. Right, RL post-training of Alpamayo-R1 maximising the expected reward.

Three rewards: a large reasoning model grades the trace, a binary check that the trace’s decision matches the trajectory, and the distance to the logged trajectory as behavior reward.

RL rewards Reasoning grade Reasoning-action consistency Close encounters, log replay
SFT only 3.1 0.62 6.9%
plus reasoning grade 4.5 0.53 5.8%
plus consistency 4.5 0.85 6.2%
plus trajectory reward 4.4 0.83 3.7%

Takeaways

  • Overview
  • Semantic space
  • Traffic modeling
  • End-to-end policies
  • Takeaways

Open questions

RL for autonomous driving has made great progress, but many exciting questions remain.

  • Reward design.
    • Correct reward to describe good driving (e.g. being considerate!)
    • Making driving human-like
  • Cost.
    • How to be as efficient as possible?
      • Algorithms (e.g. using model-based RL?)
      • Data selection/re-weighting
      • Open-loop RL vs Closed-loop SFT (DAgger) vs Closed-loop RL
      • …?
  • Sim-to-real gap.
    • How to learn with traffic models in the loop?
    • How to deal with limitations of world models?
    • How to avoid overfitting to world models?
  • Imitation-to-RL gap.
    • RL with trajectory outputs
    • How to initialize the critic?
    • Post-training-aware pretraining
    • Combining reasoning and behaviour training (e.g. closed-loop credit across reasoning and action)