A car's stopping distance grows with the square of its speed. At 15 km/h behind a slow truck, a driving system can deliberate for seconds. At 100 km/h behind a braking car, it may have a few hundred milliseconds before a fixed safety buffer forces an emergency stop. Classical safety engineering already turns this into numbers. A velocity-dependent headway, meaning a following distance that grows with speed, gives the remaining slack. Zhuyi shows that this slack determines how often perception must run. Language-model reasoners, by contrast, think until they decide to stop. They have no sense that the time available to think is set by physics.
This note proposes to teach a reasoning model one domain-general skill: commit to the best answer it can before an externally given deadline, and spend its limited thinking on whatever matters most. It learns this on cheap, automatically checkable math problems with randomized deadlines. We then test whether the skill transfers zero-shot to driving decisions, where each deadline is computed from speed and gap. The bet follows the cross-domain transfer literature, which finds that math-trained RL instills reusable habits such as planning and stopping. It asks whether "reason within a time limit" is one of those habits, and whether it helps once the limit is set by a moving vehicle.
Core Claim
The time left before a speed-dependent safety envelope forces braking can be computed in closed form. That time can be handed to a reasoning model as an explicit token deadline. Concretely, let $d$ be the gap to a hazard and $v$ the ego speed, $v_{\text{rel}}$ the closing speed, $d_0$ a standstill margin, $t_h$ a reaction headway, and $a$ the comfortable deceleration. The reasoning deadline is
$$ t_{\text{avail}} = \frac{d - \left(d_0 + v\,t_h + \tfrac{v^2}{2a}\right)}{v_{\text{rel}}}, \qquad B = r\,(t_{\text{avail}} - \ell), $$
where $\ell$ is perception latency, $r$ is the model's decoding rate in tokens per second, and $B$ is the token budget. The first term follows the headway and braking forms used in the merging and car-following work surveyed in the file. The claim is that a model trained with RL to answer well under random deadlines and in shuffled multi-question bundles on math will do two things in driving without driving-specific training. It will make better tactical choices under $B$ than the same model with naive truncation. It will also ration thought across several hazards by urgency rather than by the order in which they appear in the prompt.
The idea is not to put a language model in the control loop. A classical planner executes the chosen action, and an explicit headway envelope always vetoes unsafe actions. The language model only picks among tactical options such as yield, proceed, lane-change, or follow. This keeps safety decomposable, which VERDI explicitly gives up by distilling reasoning into a monolithic stack.
Relation to Prior Work
Two lines of work motivate the proposal without covering it. Kinematic safety work derives allowable latency from speed: Zhuyi uses worst-case braking to show an AV stays safe while processing 36% or fewer of a 30 FPS stream. Its budget, however, only gates sensor frames, never a learned reasoner. Compute-regulation work for reasoning models treats thinking length as something to trim. Self-Braking Tuning teaches models to stop once their answer is verified. DTO prunes redundant reasoning segments with preference optimization. Latency and Token-Aware Test-Time Compute routes between search strategies under an abstract latency penalty. In all three, the stopping signal comes from inside the problem, either answer confidence or a cost weight. None takes a hard external deadline that changes every step.
Two further papers supply the transfer hypothesis and the method. CPL trains abstract plan steps on math and reports +12.2% on HumanEval and +8.6% on GPQA. Reasoning Vectors isolates math-RL gains as a weight difference that transfers to BigBenchHard. SBT reports that math-only braking carried over to GPQA-Diamond. All of these transfer between symbolic tasks; none tests a physical, time-critical domain. We reuse their recipe of RL on verifiable math, and change what is rewarded: answering under deadlines.
One paper constrains the design. Thinking Hard, Not Smart shows that reasoning models solve bundled questions greedily in prompt order. Scores drop 16–19 points when hard, low-value items come first, and with 20 questions one model attempted only about 23% of them. A driving prompt listing several agents is exactly such a bundle. So the training must break order dominance directly rather than hope it disappears.
Finally, STSBench sets the input format. Text-only GPT-4o given 3D box coordinates reached 57.08%, above driving-tuned VLMs. We therefore feed the reasoner structured object lists rather than pixels, and treat perception noise separately.
Research Program
The first component is deadline-conditioned math RL. We start from Llama-3.1-8B-Instruct, a model on which SBT reports results, so the baselines are directly comparable. We train it with verifiable-reward RL on GSM8K and MATH problems packed into bundles of one to six questions. Each question carries a value and an individual token deadline, and the order is shuffled.
The output format requires the model to commit a provisional answer early and refine it afterward. We call this anytime output: whatever is committed at the deadline is what gets scored. The reward is the summed value of correct answers committed before their deadlines. Deadlines are drawn from a heavy-tailed distribution matched to the spread of $B$ values the driving domain produces.
The second component is the driving interface. Each decision tick is serialized into text: ego state, a list of tracked agents with positions and velocities, and a small menu of tactical options. Each agent is tagged with its own $t_{\text{avail}}$ from the equation above. The overall budget $B$ is the minimum over agents. A rule-based headway envelope filters the chosen option, and if the reasoner misses its deadline, a conservative default of follow-and-brake is used. Because simulated wall-clock latency is charged at a fixed $r$ tokens per second, results do not depend on GPU speed. Simulation time advances by the charged latency before the action applies.
The third component is analysis. We measure, per decision, whether thinking tokens are spent on the agent with the smallest $t_{\text{avail}}$. We also check whether the deadline skill can be extracted as a reasoning vector, the difference between deadline-trained and plain math-RL weights. If it can, it could be added to other same-architecture models.
Baselines
The naive reference is the base instruction model with unbounded thinking, charged its true latency. It shows how often an unconstrained reasoner simply runs out of time. A second naive reference is the rule-only stack: the headway envelope plus a classical planner, with no language model at all. Rule-based safety formulas are the strongest argument against using a language model here, so this point must be beaten on Driving Score and Success Rate, not only on safety.
The strongest existing compute-regulation method is SBT applied to the same base model and given the same math data. Its reported in-domain figure is 62.8% token reduction at 94.1% of baseline accuracy on Llama-3.1-8B-Instruct (Self-Braking Tuning). We pair it with hard truncation at $B$ and the same fallback. DTO and the latency-aware router of Huang et al. run as secondary baselines under the same budget. For the router there is no reported numeric result on Lacuna for NuminaMath-CoT.
On the driving side, the strongest reported closed-loop system on Bench2Drive is DriveAdapter, with a mean ability score of 42.08%. The best overtaking success across all models is 26.38% (Bench2Drive). We found no reported Driving Score for these systems on Lacuna. On STSnu, the strongest reference is GPT-4o with coordinates at 57.08%, with InternVL 2.5 8B at 46.07% (STSBench).
Every learned baseline gets the same base model, the same math data volume, the same RL compute, and the same hyperparameter search budget. Every method sees the identical serialized scene and the identical safety filter.
Two ablations isolate the key ingredients. One trains on bundles with deadlines but in a fixed order, separating the deadline skill from order-robustness. The other uses plain math RL with no deadlines, separating "more reasoning RL" from "deadline RL."
Beating the field means a statistically significant gain in deadline-scored decision accuracy and closed-loop Success Rate over SBT-plus-truncation, at equal or lower deadline-miss rate. On the high-speed and multi-agent Bench2Drive skills, it also means exceeding the rule-only stack.
Why not just…?
Why not just truncate any reasoning model at the kinematic budget and fall back to braking? This is the most natural competitor and is run as a baseline. SBT's authors report that external truncation leaves chains of thought incomplete and hurts accuracy relative to learned stopping. But that evidence is on math with generous budgets, not on driving deadlines of tens of tokens. The STSnu-with-deadlines experiment settles this directly. If truncated SBT matches our model there, the training contribution is nil and we would report the kinematic budget alone as the result.
Why not just sort agents in the prompt by time-to-collision? This is a real threat. Fan et al.'s order dominance would then work in our favor for free. We include TTC-sorted prompting as a baseline for every model. Two things could still distinguish the methods. Urgency is not identical to TTC when a less imminent agent determines feasibility, as in a merger whose gap closes the only escape lane. And real track lists are noisy, so sorting can be wrong. If sorting matches our model even on these scenarios, we drop the rationing claim and keep only the deadline-commitment claim.
Why not just fine-tune on driving data with deadlines instead of math? In CARLA, driving outcomes are verifiable, so this is feasible, and we train it as an in-domain upper reference with the same RL compute. STSBench's finding that driving-tuned models (DriveMM 39.51%) trail general models suggests in-domain tuning can overfit, but that does not prove math transfer is better. The honest question is whether math-trained deadline skill reaches most of the in-domain model's gain. We also test whether the two combine additively. If the math-trained model reaches only a small fraction, the transfer claim fails.
Proposed Experiments
The first experiment is offline and cheap. For every STSnu question we compute $t_{\text{avail}}$ from the ground-truth nuScenes kinematics of the referenced agents and convert it to $B$. A missed deadline is scored as the conservative default answer. The primary metric is deadline-scored accuracy, reported separately for Ego and Agent-to-Agent categories. Agent-to-Agent is where STSBench found a 20–30% gap. We repeat the experiment with agent order shuffled, and measure the accuracy spread between best and worst orderings as a direct order-dominance test.
The second experiment is closed-loop on Bench2Drive's 220 routes, run with simulated latency charging. Metrics are Success Rate, Driving Score, Efficiency, and Comfortness, plus three of our own: deadline-miss rate, safety-filter veto rate, and the fraction of thinking tokens spent on the minimum-$t_{\text{avail}}$ agent. Results are broken down by ego speed band. The hypothesis predicts the largest gains over truncation in the high-speed bands, where $B$ is small, and near-zero gains at low speed, where every method has ample time. That speed-dependent pattern is the decisive signature. A uniform gain across speeds would mean we merely trained a better reasoner, not a deadline-aware one.
A robustness check replaces ground-truth boxes with detector tracks. This follows the drop from 84.3% to 60.4% that NuScenes-QA reports under detector noise, and tests whether the rationing skill survives noisy urgency estimates.
A final check applies the extracted deadline vector to a second same-architecture checkpoint. This tests whether the skill is as linearly portable as the math reasoning vectors in Reasoning Vectors.
The proposal fails cleanly in either of two cases. TTC-sorted truncated SBT could match the deadline-trained model on both STSnu and Bench2Drive. Or the gains could fail to concentrate at high speed.
References
- Zhuyi: perception processing rate estimation for safety in autonomous vehicles
- VERDI: VLM-Embedded Reasoning for Autonomous Driving
- Let LRMs Break Free from Overthinking via Self-Braking Tuning
- Don’t Think Longer, Think Wisely: Optimizing Thinking Dynamics for Large Reasoning Models
- Latency and Token-Aware Test-Time Compute
- CPL: Critical Plan Step Learning Boosts LLM Generalization in Reasoning Tasks
- Reasoning Vectors: Transferring Chain-of-Thought Capabilities via Task Arithmetic
- Thinking Hard, Not Smart: Reasoning Models Fail to Ration Test-Time Compute Across Questions
- STSBench: A Spatio-temporal Scenario Benchmark for Multi-modal Large Language Models in Autonomous Driving
- Bench2Drive: Towards Multi-Ability Benchmarking of Closed-Loop End-To-End Autonomous Driving
- NuScenes-QA: A Multi-Modal Visual Question Answering Benchmark for Autonomous Driving Scenario