Pith. sign in

REVIEW 4 major objections 4 minor 1 cited by

ADRD: LLM-Driven Autonomous Driving Based on Rule-based Decision Systems

T0 review · 4 major / 4 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read LLMs can write the driving rules: ADRD turns LLM reasoning into executable decision trees that out-drive RL baselines.

desk verdict ADRD is a tidy engineering contribution that turns LLMs into an automatic generator of interpretable decision-tree driving policies, but its headline performance claims rest on an empirical protocol that is under-specified to the point of being unverifiable. read the letter →

arxiv 2506.14299 v1 pith:TO7Q6UGF submitted 2025-06-17 cs.AI

Fanzhi Zeng , Siqi Wang , Chuzhao Zhu , Li Li This is my paper · ORCID
classification cs.AI
keywords autonomousdrivingdecisiontreeslargelanguagemodelsinterpretableAIrule-basedsystemshighway-envsimulationreinforcementlearningbaselineLLMagents
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper aims to show that large language models can be used to write complete, interpretable driving policies rather than only to choose individual actions. It introduces ADRD, a three-module framework where an LLM planner proposes driving tactics, an LLM coder translates them into an executable Python decision tree, and a summarizer reads collision reports and feeds improvement advice back into the loop. On the highway-env simulator, ADRD reports the longest average safe driving time in normal, hard, and extreme scenarios when compared with PPO-CLIP reinforcement learning and the LLM-driven DiLu method, while deciding in under one microsecond per command. The payoff, if the results hold, is that rule-based decision systems can be both transparent and high-performance, and can be edited by human experts without retraining.

What carries the argument

The load-bearing mechanism is a closed agent loop with three modules. The Information Module turns raw scenario, vehicle, and traffic-rule data into natural-language descriptions; the Planner in the Agents Module converts those descriptions into named tactics with conditions and priorities; the Coder translates the tactics into an `on_step` Python function that implements a decision tree; the Testing Module runs that function in highway-env and returns collision trajectory reports; and the Summarizer decides whether the failure came from the tactics or the code and sends concrete advice back to the Planner and Coder. The executable decision tree is the central artifact: each internal node is a condition on gaps, speeds, or lane availability, and each leaf is one of five meta-actions, so inference is a sequence of comparisons rather than a model call.

What would settle it

Run the full ADRD refinement loop on one set of highway-env configurations, then evaluate the final trees on configurations with lane counts and vehicle densities that never appeared in any collision report used by the Summarizer, reporting the mean and spread of safe driving time over many seeds. If the advantage over PPO and DiLu disappears or reverses on these held-out configurations, the generality claim fails; checking the refinement logs for overlap between training scenarios and Table 1 configurations would settle the concern directly.

Watch

Extended reading notes

Core claim

ADRD claims to be the first integration of large language models with rule-based decision systems for autonomous driving. The central claim is that iteratively refined LLM-generated decision trees outperform both a conventional RL policy and a state-of-the-art LLM-based method in the highway-v0 scenario: ADRD reports average safe driving times of 25.15s, 16.75s, and 13.55s in the 4-lane, 5-lane, and 6-lane test settings, against 23.00s, 16.00s, and 10.10s for DiLu and 10.90s, 8.60s, and 5.50s for PPO. The same trees execute in under $10^{-6}$ seconds per decision, while DiLu needs roughly 12 to 14 seconds of LLM response time per decision. The author's framing is that this demonstrates a practical route to transparent, modifiable, real-time-capable driving decisions.

Load-bearing premise

The claim that ADRD is generally better at driving rests on the evaluation scenarios not having been used to refine the decision trees; if the trees were tuned on the same highway configurations that Table 1 reports, the margins could reflect overfitting to the simulator rather than a broadly superior policy.

Editorial extensions

If this is right

  • Decision-tree policies can be audited and hand-edited: changing one condition changes behavior without retraining.
  • Per-command inference cost drops to microseconds, so the decision layer can run at real-time rates on ordinary CPUs.
  • The Summarizer loop turns every collision into a concrete code or tactic revision, giving the system an automated self-improvement path without gradient updates.
  • Prompt-level driving style targets produce measurably different tree structures, so the same pipeline can deliver conservative or aggressive behavior.
  • Harder scenarios produce deeper trees, meaning the LLM automatically adds conditional detail when the driving situation demands finer distinctions.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • Editorial inference: The reported inference time of under $10^{-6}$ seconds per decision makes the decision logic effectively free; in a deployed vehicle, perception and state estimation would dominate latency, so the framework's real-time advantage must be re-evaluated end-to-end.
  • Editorial inference: Because Table 1 reports no variance across the 20 randomized runs, the small margins over DiLu in the normal scenario may not be stable; a re-analysis with standard deviations and statistical tests would tell whether the ordering is meaningful.
  • Editorial inference: The paper sets the rule system up as fully transparent, but the aggressive-policy tree reaches depth 34 with dozens of branches; at that scale, human readability may degrade, so interpretability likely has a complexity budget worth measuring.
  • Editorial inference: A natural testable extension is to run the same Planner-Coder-Summarizer loop on a different simulator or on real-world logged sensor data; if the generated trees transfer without retuning, the method's generality would be much stronger than the highway-env-only evidence.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 4 minor

Summary. ADRD is an LLM-driven framework that automatically generates and iteratively refines executable decision trees for autonomous driving in highway-env. Its three components are the Information Module, which converts environment state and driving rules into text; the Agents Module, whose Planner produces textual tactics, Coder translates them into Python on_step code, and Summarizer uses collision reports to propose improvements; and the Testing Module, which evaluates the generated code. Experiments compare ADRD against PPO-CLIP and DiLu on three configurations (4 lanes/density 2.00, 5/2.50, 6/3.00), reporting average safe driving time over 20 randomized scenarios and control efficiency. The paper claims superior performance, interpretability, and response speed relative to both baseline families.

Significance. The proposal is timely and the design is sensible: using LLMs to produce transparent, executable decision trees with closed-loop refinement is a plausible route toward interpretable driving policies, and the authors provide code and prompts. A particular strength is that the final policy is inspectable and manually modifiable, which addresses an important limitation of neural policies. If the reported results hold under proper evaluation, this would be a useful reference point for LLM-based interpretable driving research. However, the empirical evidence in its current form is not yet sufficient to support the abstract's stronger claims.

major comments (4)
  1. [Section 3.4 and Section 4.2, Table 1] The central generalization claim requires a held-out evaluation, but the manuscript does not state whether the 20 randomized scenarios used in Table 1 are disjoint from the episodes used by the Summarizer to refine the decision trees. The Summarizer receives collision reports from the same highway-env simulator and revises tactics and code (Section 3.4), so if the evaluation scenarios overlap with the refinement distribution, the reported margins reflect adaptation to the test environment rather than transferable driving ability. Please specify the precise scenario-generation protocol, seed handling, and whether the final trees were frozen before the 20 test runs.
  2. [Table 1, Section 4.2] All average driving times are point estimates over 20 runs with no standard deviations, confidence intervals, or significance tests. Some margins are small (e.g., ADRD 16.75 vs. DiLu 16.00 in the hard scenario), and without variance information a reader cannot tell whether the ordering is stable. Report per-seed results and error bars and carry out a paired test or equivalent across the 20 randomized scenarios.
  3. [Section 4.2, Table 1 control efficiency] The value '<1.0e-6 s' is only an upper bound, and the measurement methodology is absent. It is unclear whether this is a single function-call wall-clock measurement, a median over many calls, or an estimate; such a number cannot be compared meaningfully with the PPO forward-pass time or the DiLu API latency without a protocol. Please report the measurement method, hardware and software versions, and the distribution over repeated calls.
  4. [Section 4.3] The structural analysis is carried out at densities 0.75-1.25, while Table 1 evaluates at densities 2.00-3.00; the paper explicitly says the lower densities were chosen to keep training collision-free. This disconnect leaves unclear which decision trees produced the Table 1 results and whether they were refined at the evaluation densities. Please state explicitly the density and lane configuration used during refinement for each Table 1 row, and whether the evaluation scenarios were withheld from refinement.
minor comments (4)
  1. [Figure 6] Figure 6 is too small and dense to read; consider splitting it into multiple panels or increasing the resolution.
  2. [Table 2] State the exact definition of 'decision tree depth' used in Table 2 and the counting rule for nodes and branches.
  3. [Introduction and Conclusion] The claim of being 'the first work that integrates large language models with rule-based systems for autonomous driving' should be softened, because references [12] and [13] already use LLM-generated decision trees and reference [11] uses executable code as an action space.
  4. [Section 4.1 and Appendix A] Provide the number of refinement iterations and the total LLM inference cost for training; reproducibility would benefit from a detailed training log and the exact model version, temperature, and decoding settings for o3-mini.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity found: ADRD's claims are empirical and benchmarked against external baselines; lack of stated train/evaluation separation is a reproducibility caveat, not a self-referential reduction.

full rationale

ADRD's core loop is an empirical generate-test-refine procedure: the Planner and Coder produce a decision tree, the Summarizer receives collision reports and advises changes, and the final tree is evaluated in highway-env. None of the quantities in the reported comparison is defined in terms of the quantity it is supposed to establish. Table 1 compares ADRD against two external baselines (PPO-CLIP and DiLu) that were not produced by the ADRD loop, so the performance comparison has independent content. There is no fitted parameter that is renamed as a prediction, no uniqueness argument imported from the authors' prior work, and no load-bearing self-citation (the one co-authored reference [2] appears only as a related-work example). The executable-code medium is grounded in external works [11-13]. The main weakness is that the paper never states explicitly that the 20 randomized evaluation episodes were disjoint from the episodes used by the Summarizer for refinement, and Table 1 reports point estimates without variance; these are statistical-validity and reproducibility concerns, not demonstrated circularity. Under the rule that circularity must be shown by a quoted reduction, I find no qualifying circular step.

Assumptions & free parameters 0 free parameters · 4 assumptions · 0 invented entities

The central claim does not depend on a numerically fitted parameter in the classical sense. The decision-tree thresholds are chosen by the LLM and not reported as tunable constants. However, the method assumes the LLM's code generation and iterative refinement produce safe policies, and that highway-env is a valid testbed.

assumptions (4)
  • domain assumption The LLM (o3-mini) is capable of generating logically sound, executable decision-tree code from textual environment descriptions and tactics.
    The Coder module relies on this capability; no verification beyond simulation is performed.
  • domain assumption Highway-env is a valid proxy for real-world autonomous driving decision-making.
    All evaluation is in simulation; the claim of real-world deployment potential relies on this proxy.
  • domain assumption Iterative refinement through collision reports converges to a safe policy without explicit guarantee.
    The Summarizer's feedback loop is assumed to improve tactics; no theoretical or empirical convergence analysis is provided.
  • domain assumption The provided traffic rules and scenario descriptions are sufficient and complete for safe driving.
    Information Module passes these to the LLM; any incompleteness could lead to unsafe decisions.

how reviews work

0 comments
Cite this review

Pith. "Pith review of ADRD: LLM-Driven Autonomous Driving Based on Rule-based Decision Systems." pith.science (2026). https://pith.science/paper/TO7Q6UGF

@misc{pith2026250614299,
  author       = {Pith},
  title        = {Pith review of: ADRD: LLM-Driven Autonomous Driving Based on Rule-based Decision Systems},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/TO7Q6UGF}},
  note         = {Machine review of arXiv:2506.14299}
}
read the original abstract

How to construct an interpretable autonomous driving decision-making system has become a focal point in academic research. In this study, we propose a novel approach that leverages large language models (LLMs) to generate executable, rule-based decision systems to address this challenge. Specifically, harnessing the strong reasoning and programming capabilities of LLMs, we introduce the ADRD(LLM-Driven Autonomous Driving Based on Rule-based Decision Systems) framework, which integrates three core modules: the Information Module, the Agents Module, and the Testing Module. The framework operates by first aggregating contextual driving scenario information through the Information Module, then utilizing the Agents Module to generate rule-based driving tactics. These tactics are iteratively refined through continuous interaction with the Testing Module. Extensive experimental evaluations demonstrate that ADRD exhibits superior performance in autonomous driving decision tasks. Compared to traditional reinforcement learning approaches and the most advanced LLM-based methods, ADRD shows significant advantages in terms of interpretability, response speed, and driving performance. These results highlight the framework's ability to achieve comprehensive and accurate understanding of complex driving scenarios, and underscore the promising future of transparent, rule-based decision systems that are easily modifiable and broadly applicable. To the best of our knowledge, this is the first work that integrates large language models with rule-based systems for autonomous driving decision-making, and our findings validate its potential for real-world deployment.

Figures

Figures reproduced from arXiv: 2506.14299 by the authors.

Figure 1
Figure 1. Overall Stucture of ADRD. StarCraft, preliminarily validating the feasibility of this paradigm. Further work [13] combined LLM-generated decision trees with reinforcement learning, enabling co-evolution between RL agents and LLMs through mutual interaction. These emerging studies highlight the promising potential of using LLM-generated decision trees for interpretable decision-making. Code Generation for Decision-Ma… view at source ↗
Figure 2
Figure 2. specific Output Example of the Information Module. The refined information from the Information Module is then fed into the Agents Module. This module is the core component of ADRD, where the Planner, Coder, and Summarizer collaborate effectively. They not only ensure robust forward reasoning in the decision tree but also improve it based on failed interactions, achieving effective closed-loop iteration. Specificall… view at source ↗
Figure 3
Figure 3. Policy of PPO vs Policy of ADRD. 3.3 Coder The main responsibility of the Coder is to generate executable Python functions for the simulation environment based on textual driving tactics generated by the Planner. The Coder relies on the strong code-writing capabilities of current LLMs, as numerous studies have demonstrated the promising applications of LLM-generated code as an action space. The Coder’s prompt genera… view at source ↗
Figures from the paper (6 more)
Figure 4
Figure 4. Figure 4: A converged decision tree generated by ADRD. To concisely illustrate the key structure of the decision tree, some specific numerical values have been omitted. For a more detailed version of the decision trees, please refer to the Experiment section. 4 Experiments 4.1 S…
Figure 5
Figure 5. Figure 5: Decision Trees Obtained from Conservative Policies [PITH_FULL_IMAGE:figures/full_fig_p009_5.png]
Figure 6
Figure 6. Figure 6: Decision Trees Obtained from Aggressive Policies [PITH_FULL_IMAGE:figures/full_fig_p010_6.png]
Figure 7
Figure 7. Figure 7: Example Prompt Template of Planner. 13 [PITH_FULL_IMAGE:figures/full_fig_p013_7.png]
Figure 8
Figure 8. Figure 8: Example Prompt Template of Coder. 14 [PITH_FULL_IMAGE:figures/full_fig_p014_8.png]
Figure 9
Figure 9. Figure 9: Example Prompt Template of Summarizer. 15 [PITH_FULL_IMAGE:figures/full_fig_p015_9.png]

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. PolicyEvolve: Evolving Programmatic Policies by LLMs for multi-player games via Population-Based Training

    cs.LG 2025-09 conditional novelty 5.0 of 10

    PolicyEvolve evolves LLM-generated rule-based policies via a global and local pool plus trajectory reflection, and reports winning head-to-head comparisons in the Wrestle game.

Reference graph

Works this paper leans on

41 extracted references · 29 canonical work pages · cited by 1 Pith paper

  1. [1]

    Interpretable end-to-end urban autonomous driving with latent deep reinforcement learning

    Jianyu Chen, Shengbo Eben Li, and Masayoshi Tomizuka. Interpretable end-to-end urban autonomous driving with latent deep reinforcement learning. IEEE Transactions on Intelligent Transportation Systems, 23(6):5068–5078, 10 2021

    work page 2021

  2. [2]

    Chatgpt as your vehicle co-pilot: An initial attempt

    Shiyi Wang, Yuxuan Zhu, Zhiheng Li, Yutong Wang, Li Li, and Zhengbing He. Chatgpt as your vehicle co-pilot: An initial attempt. IEEE Transactions on Intelligent Vehicles, 8(12):4706–4721, 2023

    work page 2023

  3. [3]

    Dilu: A knowledge-driven approach to autonomous driving with large language models

    Licheng Wen, Daocheng Fu, Xin Li, Xinyu Cai, Tao Ma, Pinlong Cai, Min Dou, Botian Shi, Liang He, and Yu Qiao. Dilu: A knowledge-driven approach to autonomous driving with large language models. arXiv preprint arXiv:2309.16292, 2023

    arXiv 2023

  4. [4]

    Driving with llms: Fusing object-level vector modality for explainable autonomous driving

    Long Chen, Oleg Sinavski, Jan Hünermann, Alice Karnsund, Andrew James Willmott, Danny Birch, Daniel Maund, and Jamie Shotton. Driving with llms: Fusing object-level vector modality for explainable autonomous driving. In 2024 IEEE International Conference on Robotics and Automation (ICRA), pages 14093–14100. IEEE, 2024

    2024

  5. [5]

    Drivegpt4: Interpretable end-to-end autonomous driving via large language model

    Zhenhua Xu, Yujia Zhang, Enze Xie, Zhen Zhao, Yong Guo, Kwan-Yee K Wong, Zhenguo Li, and Hengshuang Zhao. Drivegpt4: Interpretable end-to-end autonomous driving via large language model. IEEE Robotics and Automation Letters, 2024

    2024

  6. [6]

    Improving language understanding by generative pre-training.(2018), 2018

    Alec Radford, Karthik Narasimhan, Tim Salimans, Ilya Sutskever, et al. Improving language understanding by generative pre-training.(2018), 2018

    work page 2018

  7. [7]

    Language models are unsupervised multitask learners

    Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, Ilya Sutskever, et al. Language models are unsupervised multitask learners. OpenAI blog, 1(8):9, 2019

    2019

  8. [8]

    Language models are few-shot learners

    Ben Mann, N Ryder, M Subbiah, J Kaplan, P Dhariwal, A Neelakantan, P Shyam, G Sastry, A Askell, S Agarwal, et al. Language models are few-shot learners. arXiv preprint arXiv:2005.14165, 1:3, 2020

    arXiv 2005

Show all 41 references
  1. [9]

    Gpt-4 technical report

    Josh Achiam, Steven Adler, Sandhini Agarwal, Lama Ahmad, Ilge Akkaya, Florencia Leoni Aleman, Diogo Almeida, Janko Altenschmidt, Sam Altman, Shyamal Anadkat, et al. Gpt-4 technical report. arXiv preprint arXiv:2303.08774, 2023

    2023 arXiv

  2. [10]

    Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning

    Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Ruoyu Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang, Xiao Bi, et al. Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning. arXiv preprint arXiv:2501.12948, 2025

    2025 arXiv

  3. [11]

    Executable code actions elicit better llm agents, 2024

    Xingyao Wang, Yangyi Chen, Lifan Yuan, Yizhe Zhang, Yunzhu Li, Hao Peng, and Heng Ji. Executable code actions elicit better llm agents, 2024

    2024

  4. [12]

    Smac-r1: The emergence of intelligence in decision-making tasks, 2025

    Yue Deng, Weiyu Ma, Yuxin Fan, Ruyi Song, Yin Zhang, Haifeng Zhang, and Jian Zhao. Smac-r1: The emergence of intelligence in decision-making tasks, 2025

    2025

  5. [13]

    Rl-llm-dt: An automatic decision tree generation method based on rl evaluation and llm enhancement, 2024

    Junjie Lin, Jian Zhao, Lin Liu, Yue Deng, Youpeng Zhao, Lanxiao Huang, Xia Lin, Wengang Zhou, and Houqiang Li. Rl-llm-dt: An automatic decision tree generation method based on rl evaluation and llm enhancement, 2024

    2024

  6. [14]

    An overview of production systems

    Randall Davis and Jonathan King. An overview of production systems. Stanford University, 1975

    1975

  7. [15]

    Expert system methodologies and applications—a decade review from 1995 to 2004

    Shu-Hsien Liao. Expert system methodologies and applications—a decade review from 1995 to 2004. Expert systems with applications, 28(1):93–103, 2005

    1995

  8. [16]

    Fuzzy sets

    Lotfi Asker Zadeh. Fuzzy sets. Information and control, 8(3):338–353, 1965

    1965

  9. [17]

    Decision trees for decision making

    John F Magee. Decision trees for decision making. Harvard Business Review Brighton, MA, USA, 1964

    1964

  10. [18]

    Decision trees

    Lior Rokach and Oded Maimon. Decision trees. Data mining and knowledge discovery handbook, pages 165–192, 2005

    2005

  11. [19]

    Decision trees: a recent overview

    Sotiris B Kotsiantis. Decision trees: a recent overview. Artificial Intelligence Review, 39:261–283, 2013

    2013

  12. [20]

    Classification and regression trees

    Wei-Yin Loh. Classification and regression trees. Wiley interdisciplinary reviews: data mining and knowledge discovery, 1(1):14–23, 2011

    2011

  13. [21]

    Ross Quinlan

    J. Ross Quinlan. Induction of decision trees. Machine learning, 1:81–106, 1986

    1986

  14. [22]

    Evaluating large language models trained on code

    Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde De Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, et al. Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374, 2021

    2021 arXiv

  15. [23]

    CERT: Continual pre-training on sketches for library-oriented code generation

    Daoguang Zan, Bei Chen, Dejian Yang, Zeqi Lin, Minsu Kim, Bei Guan, Yongji Wang, Weizhu Chen, and Jian-Guang Lou. CERT: Continual pre-training on sketches for library-oriented code generation. In The 2022 International Joint Conference on Artificial Intelligence, 2022

    2022

  16. [24]

    GPT-Neo: Large Scale Autoregressive Language Modeling with Mesh-Tensorflow, March 2021

    Sid Black, Leo Gao, Phil Wang, Connor Leahy, and Stella Biderman. GPT-Neo: Large Scale Autoregressive Language Modeling with Mesh-Tensorflow, March 2021. 11

    2021

  17. [25]

    Explainable artificial intelligence for autonomous driving: A comprehensive overview and field guide for future research directions

    Shahin Atakishiyev, Mohammad Salameh, Hengshuai Yao, and Randy Goebel. Explainable artificial intelligence for autonomous driving: A comprehensive overview and field guide for future research directions. IEEE Access, 2024

    2024

  18. [26]

    Proximal policy optimization algorithms

    John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017

    2017 arXiv

  19. [27]

    Competitive programming with large reasoning models

    Ahmed El-Kishky, Alexander Wei, Andre Saraiva, Borys Minaiev, Daniel Selsam, David Dohan, Francis Song, Hunter Lightman, Ignasi Clavera, Jakub Pachocki, et al. Competitive programming with large reasoning models. arXiv preprint arXiv:2502.06807, 2025. 12 A Prompt Templates A.1...

    2025 arXiv

  20. [28]

    Analyze the road information I provided to you

  21. [29]

    LANE_LEFT

    Provide tactics to guide the ego vehicle to drive **safely and efficiently** both in the provided scenario and generalizable to other scenarios. Given one scenario, your tactics should be able to select the proper **Meta Actions** ("LANE_LEFT", "IDLE", "LANE_RIGHT", "FASTER", ...

  22. [30]

    Follow driving target statements, such as conservative or aggressive

  23. [31]

    In these cases, you should consider changing lanes to a lane with wider gap or overtaking if it's possible

    Sometimes, only reducing speed or maintaining the current state can't avoid a collision since there is a minimum speed for the ego vehicle. In these cases, you should consider changing lanes to a lane with wider gap or overtaking if it's possible

  24. [32]

    It's impossible to brake in this scenario

    There is no braking action in the Meta Actions. It's impossible to brake in this scenario

  25. [33]

    You **must strictly adhere** to these rules when providing tactics, prioritizing them to ensure safety

    A list of driving rules are also provided to you. You **must strictly adhere** to these rules when providing tactics, prioritizing them to ensure safety. Handling Refinement After Collisions If a collision has occurred with your previous tactics, you will receive:

  26. [34]

    A collision history showing the environment and actions taken before the collision

  27. [35]

    Specific refinement advice highlighting issues with your previous tactics

  28. [36]

    ### Road Information:

    A description of the current environment When refining tactics after a collision: … Available Environment Information You can use the following variables to analyze the current road environment: ### Vehicle Information: ... ### Road Information: ... Response format After thoro...

  29. [37]

    Analyze the current road environment

  30. [38]

    Select the most appropriate Meta Action based on the provided tactics

  31. [39]

    ### Road Information:

    Return the decision result Available Environment Information You can use the following variables to analyze the current road environment: ### Vehicle Information: ... ### Road Information: ... Available Meta Actions Your `on_step` function should return one of the following fi...

  32. [40]

    Planner Issues: - Tactics that don't consider all safety scenarios - Overly aggressive strategies - Missing important driving conditions - Contradictory or ambiguous rules

  33. [41]

    Coder Issues: - Incorrect implementation of safety checks - Logic errors in condition evaluation - Missing edge cases in the code - Performance or timing issues Collision Reports Here is the previous code, which needs improvement:{past_codes} Here is the refinement advice:{adv...

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.