AdaThinkDrive: Adaptive VLA for Autonomous Driving

• AdaThinkDrive is a unified Vision–Language–Action framework that adaptively selects between fast trajectory prediction and slow chain-of-thought reasoning based on scene complexity.
• It integrates a dual-mode output mechanism within a multimodal transformer, leveraging reinforcement learning to balance inference cost and planning quality.
• The system achieves state-of-the-art PDMS scores on NAVSIM by dynamically adjusting its reasoning depth, outperforming fixed-mode baselines in both simple and challenging scenarios.

AdaThinkDrive is a unified Vision–Language–Action (VLA) framework for end-to-end trajectory prediction in autonomous driving that uses a dual mode reasoning mechanism inspired by fast and slow thinking. It addresses a specific limitation of recent Chain of Thought (CoT) integration in VLA models: CoT demonstrates promising capabilities in end to end autonomous driving, but recent efforts to integrate CoT reasoning often fall short in simple scenarios, introducing unnecessary computational overhead without improving decision quality. AdaThinkDrive departs from the “always-think” or “never-think” extremes by endowing a single model with two output modes—fast (no Chain-of-Thought) and slow (with CoT)—and learning via reinforcement to pick the right mode for each scene. The reported result is state-of-the-art planning quality on NAVSIM, with PDMS $= 90.3$, together with a 14% cut in inference cost compared to an always-think system (Luo et al., 17 Sep 2025).

1. Problem setting and design rationale

The central design premise of AdaThinkDrive is that reasoning should be conditional on scene requirements rather than uniformly imposed. In the formulation reported for autonomous driving, CoT is useful in challenging scenes but can be counterproductive in simple ones, where it may add latency and fail to improve trajectory quality. The framework therefore introduces adaptive reasoning rather than treating deliberative generation as a fixed property of the model (Luo et al., 17 Sep 2025).

This design is expressed as a dual-mode output regime. The model can operate in a Non-Thinking mode, described as “fast,” or in a Thinking mode, described as “slow.” The distinction is not implemented as two separate systems; it is implemented within a single VLA model that learns to distinguish between scenarios that require reasoning. A plausible implication is that AdaThinkDrive treats reasoning depth as a control variable in the planning loop rather than as a universal decoding heuristic.

The paper frames this choice against two extremes. An “always-think” policy corresponds to routine CoT generation, even when a scene does not benefit from it. A “never-think” policy corresponds to direct trajectory prediction without explicit reasoning traces. AdaThinkDrive is presented as a learned compromise between these extremes, with a reward-driven mechanism that determines when each mode is preferable.

2. Architecture and output modes

The base VLA backbone is a multimodal transformer, exemplified by InternVL3-8B, that encodes four input streams: an RGB front-view image $q_{\text{cam}}$, a high-level navigation command $q_{\text{com}}$ such as “Turn Left,” ego-state variables $q_{\text{ego}}$ including velocity and acceleration, and historical trajectory frames $q_{\text{his}}$ (Luo et al., 17 Sep 2025). These inputs are processed by a shared encoder-decoder backbone.

On top of this backbone, AdaThinkDrive uses a dual-mode output head. In Non-Thinking mode, the decoder is prompted to directly emit:

$\pi(m \mid q)$9

In Thinking mode, the decoder emits:

$P(\text{Thinking} \mid q)$0

The difference is therefore not only internal computation but also output structure. The model can either produce a direct trajectory or a full CoT trace followed by the final trajectory.

Mode selection is handled by a policy $\pi(m \mid q)$, implemented as a small classification head on top of the shared encoder. This head predicts $P(\text{Thinking} \mid q)$ versus $P(\text{Non-Thinking} \mid q)$. At inference, the system picks the arg max mode and then generates the corresponding style. This makes mode selection part of the learned model rather than a manually specified rule. This suggests that the planning architecture couples trajectory generation and reasoning-style selection through a single latent scene representation.

3. Pretraining and two-mode supervised fine-tuning

AdaThinkDrive is trained in three stages: large-scale driving QA pretraining, two-mode supervised fine-tuning (SFT), and adaptive thinking via Group Relative Policy Optimization (GRPO) (Luo et al., 17 Sep 2025). The first stage is intended to acquire world knowledge and driving commonsense before task-specific adaptation.

The driving QA pretraining corpora are DriveLM, LingoQA, ImpromptuVLA, NuScenes-QA, NuInstruct, and OmniDrive. In addition, multi-turn QA is constructed on NAVSIM subtasks, specifically road boundary estimation, critical object ID, and ego-action prediction, all following a CoT style. The stated objective is to maximize $$\log P(\text{answer} \mid \text{question}, \text{image})$$ across these datasets, thereby instilling world knowledge such as traffic rules and drivable areas, together with driving common-sense such as which agents matter and what to predict next.

The second stage introduces a two-mode SFT dataset. For each NAVSIM query $q$, the dataset contains two targets:

• $q_{\text{cam}}$0: final trajectory only
• $q_{\text{cam}}$1: full CoT trace plus final trajectory

Scene complexity is pre-labeled via $q_{\text{cam}}$2 based on proximity to road boundaries and presence of critical objects. The supervised objective is

$q_{\text{cam}}$3

By showing both styles for every $q_{\text{cam}}$4, the model learns to generate either fast or slow outputs under a unified interface. A plausible implication is that SFT establishes mode controllability before reinforcement learning refines when the modes should be used.

4. Adaptive Think Reward and GRPO optimization

The reinforcement-learning stage adds an Adaptive Think Reward strategy in conjunction with Group Relative Policy Optimization. For a scene $q_{\text{cam}}$5, mode $q_{\text{cam}}$6, and generated output $q_{\text{cam}}$7, the total per-sample reward is

$q_{\text{cam}}$8

The reward components are defined explicitly. $q_{\text{cam}}$9. $q_{\text{com}}$0 if the format tags $q_{\text{com}}$1 and $q_{\text{com}}$2 are correct, else $q_{\text{com}}$3. $q_{\text{com}}$4 is a piecewise function of endpoint $q_{\text{com}}$5 error, specified as $q_{\text{com}}$6 if $q_{\text{com}}$7, $q_{\text{com}}$8 if $q_{\text{com}}$9, and so on (Luo et al., 17 Sep 2025).

The adaptive component teaches the model when thinking helps. Over $q_{\text{ego}}$0 rollouts, let $q_{\text{ego}}$1 be the average PDMS of Thinking rollouts, $q_{\text{ego}}$2 the average PDMS of Non-Thinking rollouts, $q_{\text{ego}}$3 and $q_{\text{ego}}$4 their counts, and let the confidence threshold be $q_{\text{ego}}$5. For a scene labeled $q_{\text{ego}}$6 (simple), if $q_{\text{ego}}$7, $q_{\text{ego}}$8, and $q_{\text{ego}}$9, the system concludes “actually challenging,” rewards Thinking with $q_{\text{his}}$0, and rewards Non-Thinking with $q_{\text{his}}$1. Otherwise it keeps “simple,” rewards Non-Thinking with $q_{\text{his}}$2, and Thinking with $q_{\text{his}}$3. The rule is symmetric for $q_{\text{his}}$4. The paper states that this dynamic re-labeling prevents collapse on one mode.

The GRPO objective, adapted from R1 algorithms, is

$q_{\text{his}}$5

where

$q_{\text{his}}$6

At inference, the reported pseudocode is:

$P(\text{Thinking} \mid q)$1

This optimization structure formalizes selective reasoning as a policy-learning problem rather than as a prompt-engineering choice.

5. NAVSIM evaluation and quantitative results

Evaluation is conducted on the NAVSIM benchmark. The planning metric is PDMS, defined as

$q_{\text{his}}$7

where NC is No-collision rate, DAC is Drivable-area compliance, TTC is Time-to-collision safety, Comfort is jerk and acceleration, and EP is ego progress (Luo et al., 17 Sep 2025).

The main closed-loop comparison for vision-only methods reports the following values:

Method	PDMS	Inference time
Non-Think RL	88.3	0.68 s
Think RL	88.9	0.86 s
AdaThinkDrive	90.3	0.74 s

These figures support three specific claims. First, AdaThinkDrive surpasses the best vision-only baseline by 1.7 points. Second, it surpasses both the never Think and always Think baselines, improving PDMS by 2.0 and 1.4, respectively. Third, it reduces inference time by 14% compared to the always Think baseline.

A Best-of-$q_{\text{his}}$8 decoding variant of AdaThinkDrive reaches 93.0 PDMS. The reported mode usage also varies strongly with scene complexity: on the test set, Level 1 (simple) scenes use Non-Thinking in 84% of cases, while Level 3 (challenging) scenes use Thinking in 96% of cases. This suggests that the learned policy is not merely oscillating between modes, but is aligned with the predefined notion of scene difficulty.

6. Ablations, scene-level behavior, and interpretive significance

The ablation studies isolate the contribution of each training stage. SFT only yields PDMS $q_{\text{his}}$9. Adding pretraining on QA increases performance to $\pi(m \mid q)$0, a gain of $\pi(m \mid q)$1. Adding RL with Adaptive Think raises PDMS to $\pi(m \mid q)$2, a further gain of $\pi(m \mid q)$3 (Luo et al., 17 Sep 2025). In the reported configuration, the largest increment is therefore associated with the adaptive reinforcement-learning stage.

Reward design is also ablated directly. Using PDMS only gives $\pi(m \mid q)$4. Adding the format reward gives $\pi(m \mid q)$5. Adding Endpoint and Adaptive reward terms gives $\pi(m \mid q)$6. Within the stated formulation, this indicates that syntactic correctness and endpoint-sensitive adaptation contribute to final planning quality rather than serving as auxiliary training signals with no measurable effect.

Scene-level gains further differentiate the dual-mode policy from fixed-mode baselines. In simple Level 1 scenes, AdaThinkDrive surpasses Non-Think by $\pi(m \mid q)$7 PDMS. In challenging Level 3 scenes, it outperforms Think by $\pi(m \mid q)$8 PDMS. Qualitative examples reinforce this asymmetry: in a sparse highway scene, unnecessary CoT can divert the trajectory out of lane, whereas in a crowded intersection, skipping CoT leads to unsafe proximity. A common misconception is that adding CoT reasoning uniformly improves end-to-end autonomous driving; the reported ablations and examples indicate instead that CoT is conditionally beneficial, and that the key modeling problem is when to think rather than whether to think.

In summary, the reported evidence supports a specific interpretation of adaptive reasoning in autonomous driving. AdaThinkDrive demonstrates that augmenting a VLA model with a learned, reward-driven strategy for selective chain-of-thought improves closed-loop driving performance and reduces inference cost. Its three-stage pipeline—QA pretraining, two-mode SFT, and GRPO with an Adaptive Think Reward—combines fast reflexes and slow deliberation within a single end-to-end trajectory prediction framework (Luo et al., 17 Sep 2025).