Pith. sign in

REVIEW 3 major objections 5 minor 45 references

Autoware.Flex: Human-Instructed Dynamically Reconfigurable Autonomous Driving Systems

T0 review · 3 major / 5 minor · reviewed 2026-08-11 · deepseek-v4-flash

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

Pith's one-line read Autoware.Flex aims to translate plain-language driver commands into validated parameter changes that a modular self-driving system can execute safely.

desk verdict A credible LLM+RAG-to-Autoware integration whose safety claim outruns its rule-based validation; worth refereeing, but the abstract overpromises. read the letter →

arxiv 2412.16265 v3 pith:7IT6V3B7 submitted 2024-12-20 cs.AI cs.HCcs.RO

Ziwei Song , Mingsong Lv , Tianchi Ren , Chun Jason Xue , Jen-Ming Wu , Nan Guan This is my paper · ORCID
classification cs.AIcs.HCcs.RO
keywords AutonomousDrivingSystemhuman-instructedlargelanguagemodelretrieval-augmentedgenerationAutoIRrule-basedvalidationAutowareROS2
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

Autoware.Flex is an attempt to let a human passenger steer an existing modular self-driving system with ordinary language, rather than leaving all decisions to the vehicle. The paper argues that natural-language instructions can be translated into structured AutoIR programs that tell Autoware which module, node, and parameter to change, and that a rule-based checker can decide in real time whether executing the change is safe. The payoff, if the claim holds, is that an ADS can handle special cases it would otherwise get wrong, such as a malfunctioning traffic light, and can honor individual preferences such as cruising in a particular lane. Experiments in simulation and on a prototype vehicle are used to support the claim that the system effectively interprets human instructions and executes them safely.

What carries the argument

The load-bearing mechanism is the pairing of two languages: AutoIR, a small domain-specific language that encodes a user instruction as a module, node, parameter, configuration value, and lifetime, and the validation rule base, in which each admissible AutoIR program maps to a rule with a search index and safety conditions. The conditions are deliberately limited to three observable vehicle-status groups, namely motion state, speed, and perceptions including detected obstacles and traffic lights, plus a manually set timer that forces rollback to the ADS defaults. The rule base is generated offline from a small set of simulated scenarios, organized in a tree for fast lookup, and checked against the live vehicle status every validation round until the instruction expires; algorithmically, matching a rule takes a negligible fraction of a control cycle.

What would settle it

Run the red-light override scenario in the same simulator setup used in the paper, with another vehicle or pedestrian crossing the intersection on the conflicting green phase while the ego vehicle is stopped at a detected red light. If, after the human instruction is accepted, the vehicle moves into the path of the crossing road user because the matched rule does not consider cross traffic, the central claim that instructions are executed safely is false. The same test can be repeated for every rule by finding a state that satisfies the rule's conditions but where execution leads to a collision.

Watch

Extended reading notes

Core claim

The central claim is that a rule-based modular autonomous driving system can accept human driving instructions written in natural language, convert them into parameter changes at selected Autoware nodes, and execute those changes only when a small set of runtime conditions is satisfied. Instruction translation is carried out by an LLM assisted by a compact, ADS-specific knowledge base through retrieval-augmented generation; the output is an AutoIR program specifying module, node, parameter, configuration value, and a timer. Execution is gated by an offline-built rule base: each rule pairs an AutoIR search index with conditions over the vehicle's motion state, speed, and perceived objects, and an instruction is activated only while its rule matches real-time vehicle status. The paper reports that all tested instructions were executed correctly in simulation and in three real-world scenarios, while native Autoware either stopped or failed to follow the requested behavior, and that accepted instructions revert to default settings when their timer expires.

Load-bearing premise

The whole safety argument rests on a hand-built rule base that was derived from a small number of simulated scenarios and checks only motion state, speed, and perceived objects; if that rule base misses a relevant road-user situation, an accepted instruction can be unsafe.

Editorial extensions

If this is right

  • A user can instruct the vehicle to ignore a malfunctioning red light and proceed, something native Autoware cannot do, with the instruction active only while the vehicle is stopped at $0$ m/s and a traffic light is perceived.
  • Instructions that do not match a rule, or that are issued when conditions are not met, are ignored, so the rule set defines the envelope of acceptable human override.
  • Because every validated instruction carries a timer, behavior changes are temporary and the original Autoware parameters are restored automatically, limiting the duration of any override.
  • The rule-matching overhead is reported small enough, under one millisecond per check, that validation can run inside the normal control loop without noticeable delay.
  • System designers can incrementally expand the rule base to support additional instructions and scenarios, extending the safe scope over time.

Reading between the lines

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

  • An implication the paper leaves implicit is that the safety guarantee is only as strong as the rule base, and the current rules check a narrow slice of the situation; for the red-light override, for example, nothing in the stated rule verifies that cross traffic is absent before the vehicle moves.
  • The same translation-and-validation architecture could be applied to other modular driving stacks beyond Autoware, by rebuilding the knowledge base and rule base around a different parameter set, though the paper does not claim this.
  • A natural testable extension is to infer the instruction lifetime from the instruction itself rather than hard-coding ten seconds, which the paper lists as future work.
  • One could measure how often users issue instructions that are rejected by validation and treat rejection frequency as a signal for expanding the rule base or improving translation accuracy.
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

3 major / 5 minor

Summary. The paper presents Autoware.Flex, an extension of Autoware.Universe that allows users to issue natural-language driving instructions. The system uses an LLM with an ADS-specific knowledge base under a RAG architecture to translate instructions into AutoIR programs, and a rule-based validation component that checks coarse vehicle state before injecting parameter overrides into Autoware. The evaluation reports translation accuracy on a self-authored AutoIR dataset, latency measurements, two simulated scenarios, and three real-world parking-lot experiments. The abstract and Section 6.3 claim that the system effectively interprets human instructions and executes them safely.

Significance. If the central claims held, the paper would make a useful contribution to human-instructed AD systems: it demonstrates an end-to-end pipeline from natural language to validated Autoware parameter changes on a real vehicle, and the RAG-based translation shows a large improvement over using the raw Autoware manual (Table 1). The authors also contribute a 200-item translation dataset, which would be valuable to the community if released. However, the significance is tempered by the limited evidence: the safety argument rests on a small hand-built rule base, the evaluation uses only two simulator scenarios and three real-world qualitative experiments, and the translation ground truth was created by the same team from the same documentation that informed the knowledge base.

major comments (3)
  1. [4.1, 4.2, Table 3, Algorithm 1] The safety validation checks only module, node, parameter, and coarse vehicle state; it does not check the translated configAction value or dynamic hazards. For example, the 'Use the opposite lane' rule in Table 3 requires only Motion State: Driving, Speed: <5 m/s, and Obstacle Detected, with no requirement that the opposite lane be clear; the red-light rule requires only Stopped, 0 m/s, and Traffic Light Detected, with no cross-traffic check. Algorithm 1 returns Activated on the first matching state and the parameter override persists for the manually set 10-second timer, so an accepted instruction can commit the vehicle to crossing an intersection or entering oncoming traffic. This directly undercuts the unqualified 'executes them safely' claim in the abstract. The paper itself concedes in Section 4.1 that the rule base 'reflects typical driving scenarios' and cannot enumerate all situations; this scope limitation should be reflected in the safety claim.
  2. [6.1.1, 3.2.2] The translation accuracy results may overstate generalizability because the ground-truth AutoIR dataset was created by the same authors and from the same Autoware documentation used to build the knowledge base. The evaluation is therefore partly a consistency check between the LLM's output and the authors' own mapping, rather than a measure of whether the mapping is objectively correct. The dataset is not released, and no confidence intervals or per-item breakdowns are reported. A concrete test would be to have independent annotators, blind to the knowledge base, create ground-truth pairs from a different Autoware version or from recorded driving logs. In addition, the 87% ConfigAction accuracy is not reflected in the safety validation, since configAction is not among the rule conditions checked in Algorithm 1.
  3. [6.2, 6.3] Experimental evidence for the headline claim is thin and entirely positive: only two simulator scenarios (three paraphrases each) and three real-world parking-lot experiments are reported, with no failure cases and no quantitative safety metrics such as distances, speeds, time-to-collision, or lateral clearances. The real-world experiments are described qualitatively (e.g., 'successfully stop approximately three meters'), and the conclusion in Section 6.3 that the results 'strongly demonstrate' safe execution is disproportionate to the evidence. Additional experiments with adversarial instructions, unexpected traffic, and explicit measurement of safety margins are needed to support the general claim.
minor comments (5)
  1. [6.1.2] Accuracy percentages in Table 1 and the relevance-analysis results are based on 200 items; reporting exact counts and confidence intervals would make the comparisons more informative.
  2. [Tables 2 and 3] The speed conditions are written inconsistently as 'Speed: <5 m/s' and 'Speed: = 0 m/s'; please clarify whether 0 m/s means exactly zero or a small threshold.
  3. [References] Reference [21] has a typo in the year ('20222'), and the model name is written inconsistently as 'QWenVL' in Section 5 and 'Qwen-VL' in the references; please standardize.
  4. [6.2] The authors state that a traffic officer is assumed but not visually represented in the simulator; this should be acknowledged as a limitation when interpreting the scenario as validating the traffic-officer use case.
  5. [5] The implementation section would benefit from stating whether the knowledge base, dataset, and rule base are publicly available, as this affects reproducibility.

Circularity Check

1 steps flagged · score 4.0 of 10

Translation accuracy is partly self-referential: the ground-truth AutoIR dataset and the RAG knowledge base are both constructed by the same authors from the same Autoware analysis, so the reported accuracy partly measures reproduction of the authors' own mapping.

  1. self definitional [Section 3.2.2 (AutoIR generation and knowledge base) and Section 6.1.1 (AutoIR dataset)]
    ""we build a specialized ADS knowledge base derived from Autoware documentation. Each entry in the knowledge base pairs a driving scenario (representing a type of user instructions) with the corresponding AutoIR program." ... "we develop a custom AutoIR dataset based on an in-depth analysis of Autoware to serve as the ground truth. These AutoIR programs are carefully crafted based on our extensive experience with Autoware and further verified through simulation to ensure they result in the correct driving behavior.""

    The 'correct' mapping from natural language to AutoIR is defined by the authors' own dataset, and the knowledge base that the LLM retrieves from is built from the same authors' analysis of the same Autoware documentation. The accuracy results in Table 1 therefore measure whether the LLM reproduces the authors' module/node/parameter/value mapping, not whether that mapping is uniquely correct or externally validated. The simulation check in Section 6.1.1 only confirms that a crafted AutoIR program changes behavior as intended; it does not independently validate the selected mapping as ground truth. This makes the translation benchmark substantially self-consistent by construction.

full rationale

The paper contains no load-bearing self-citation chain, no imported uniqueness theorem, and no ansatz smuggled in via citation; the core engineering contributions are evaluated with simulations and a real prototype vehicle. The clearest circular step is in the instruction-translation evaluation: the ground-truth AutoIR dataset and the RAG knowledge base are both authored by the same team from the same Autoware analysis, so the reported translation accuracy is partly a measure of how well the LLM retrieves the authors' own mapping rather than an externally grounded correctness result. The safety-validation experiments are more independent evidence, though the rule base is derived from simulator scenarios and then exercised in similar simulator scenarios; that loop is a soundness concern more than a strict derivation collapse. Overall, the central claim retains independent empirical content, but the translation benchmark is partially self-referential, giving a moderate circularity score.

Assumptions & free parameters 3 free parameters · 5 assumptions · 0 invented entities

The central claim rests on manually chosen timers and speed thresholds, a hand-built rule base, an author-created evaluation dataset, and unverified assumptions about runtime parameter toggling and LLM output reliability. No new physical entities are postulated.

free parameters (3)
  • Instruction lifetime timer = 10 seconds
    Section 4.1 and 4.2: manually and conservatively encoded; authors state it can be optimized per instruction.
  • Lane-change speed threshold = <5 m/s
    Table 2 rule condition: chosen by hand during offline rule design; no derivation or sensitivity analysis.
  • Knowledge base chunk size = 700 tokens
    Section 5: chosen for RAG segmentation; no sensitivity analysis reported.
assumptions (5)
  • domain assumption Runtime ros2 param set and subsequent restore is a safe and sufficient mechanism to execute user instructions.
    Section 5 assumes toggling Autoware node parameters at runtime and restoring after a timer preserves system integrity; no failure analysis is given.
  • domain assumption The manually constructed rule base, derived from a few simulated scenarios, is representative enough to guarantee safety for accepted instructions.
    Section 4.1 acknowledges the rule base limits scope; safety for unseen scenarios is assumed, not proven.
  • domain assumption The authors' AutoIR dataset is a valid ground truth for translation correctness.
    Section 6.1.1: dataset is created in-house because no benchmark exists; it is unreleased and built from the same Autoware knowledge used to design the KB.
  • domain assumption AWSIM and parking-lot experiments approximate real driving conditions for the claimed safety behavior.
    Section 6.2 and 6.3 use low-speed, low-traffic, selected scenarios; no dense traffic or adversarial conditions are tested.
  • domain assumption The commercial LLM (QWenVL-Max) will reliably follow the output-format and selection instructions in the prompt.
    Section 3.2 and 5 rely on API behavior; no formal output guarantee, only sample accuracy.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Autoware.Flex: Human-Instructed Dynamically Reconfigurable Autonomous Driving Systems." pith.science (2026). https://pith.science/paper/7IT6V3B7

@misc{pith2026241216265,
  author       = {Pith},
  title        = {Pith review of: Autoware.Flex: Human-Instructed Dynamically Reconfigurable Autonomous Driving Systems},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/7IT6V3B7}},
  note         = {Machine review of arXiv:2412.16265}
}
abstract

Existing Autonomous Driving Systems (ADS) independently make driving decisions, but they face two significant limitations. First, in complex scenarios, ADS may misinterpret the environment and make inappropriate driving decisions. Second, these systems are unable to incorporate human driving preferences in their decision-making processes. This paper proposes Autoware$.$Flex, a novel ADS system that incorporates human input into the driving process, allowing users to guide the ADS in making more appropriate decisions and ensuring their preferences are satisfied. Achieving this needs to address two key challenges: (1) translating human instructions, expressed in natural language, into a format the ADS can understand, and (2) ensuring these instructions are executed safely and consistently within the ADS' s decision-making framework. For the first challenge, we employ a Large Language Model (LLM) assisted by an ADS-specialized knowledge base to enhance domain-specific translation. For the second challenge, we design a validation mechanism to ensure that human instructions result in safe and consistent driving behavior. Experiments conducted on both simulators and a real-world autonomous vehicle demonstrate that Autoware$.$Flex effectively interprets human instructions and executes them safely.

Figures

Figures reproduced from arXiv: 2412.16265 by the authors.

Figure 1
Figure 1. A complex scenario: traffic lights malfunction, [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. An overview of Autoware.Flex related to driving are processed further. Second, if the user instruction is relevant, it serves as the input to generate the corresponding AutoIR program. The detailed workflow is shown in [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. The workflow of user instruction translation [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (10 more)
Figure 4
Figure 4. Figure 4: The architectures of Autoware and ROS 2 AutoIR: moduleSelect: planning nodeSelect: behavior_path_planner paramSelect: use_opposite_lane configAction: FALSE [PITH_FULL_IMAGE:figures/full_fig_p004_4.png]
Figure 5
Figure 5. Figure 5: An example of an AutoIR program 3.2.2 AutoIR Semantics and Generation. The semantics of AutoIR define how user instructions are translated into meta￾data used for ROS 2 implementation. An AutoIR program consists of several domains of information, as exemplified in [PI…
Figure 6
Figure 6. Figure 6: The workflow for the design of the rule base [PITH_FULL_IMAGE:figures/full_fig_p005_6.png]
Figure 7
Figure 7. Figure 7: The workflow of instruction validation following subsection.) We note that the number of driving scenarios and AutoIR programs used during rule generation limits the number of generated rules and, consequently, the scope of acceptable user instructions. While it is imp…
Figure 8
Figure 8. Figure 8: Examples of the Simple Prompt template and [PITH_FULL_IMAGE:figures/full_fig_p008_8.png]
Figure 9
Figure 9. Figure 9: The results of latency evaluation for user instruction translation [PITH_FULL_IMAGE:figures/full_fig_p009_9.png]
Figure 10
Figure 10. Figure 10: Two scenarios to evaluate user instruction execution. (a) is the HDMap used in AWSIM, i.e., the routes [PITH_FULL_IMAGE:figures/full_fig_p009_10.png]
Figure 11
Figure 11. Figure 11: The simulated driving environment in the [PITH_FULL_IMAGE:figures/full_fig_p009_11.png]
Figure 12
Figure 12. Figure 12: The prototype autonomous vehicle used in [PITH_FULL_IMAGE:figures/full_fig_p010_12.png]
Figure 13
Figure 13. Figure 13: Scenes from the real-world experiments: (a) depicts Experiment 1, Adjusting Distance to a Pedestrian, [PITH_FULL_IMAGE:figures/full_fig_p011_13.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

45 extracted references · 33 canonical work pages

  1. [1]

    [n. d.]. ROS2 Humble. https://docs.ros.org/en/humble/index.html

    work page

  2. [2]

    Aliyun. 2024. Cloud A. Dashscope: dashscope client SDK library. https://dashscope.aliyun.com

    work page 2024

  3. [3]

    Matthias Althoff, Markus Koschi, and Stefanie Manzinger. 2017. Com- monRoad: Composable benchmarks for motion planning on roads. In 2017 IEEE Intelligent Vehicles Symposium (IV) . IEEE, 719–726

    work page 2017

  4. [4]

    Daniel Atherton. 2022. Incident 434: Sudden Braking by Tesla Allegedly on Self-Driving Mode Caused Multi-Car Pileup in Tunnel. AI Inci- dent Database, Khoa Lam (Ed.). Responsible AI Collaborative. Retrieved February 13 (2022), 2023

    work page 2022

  5. [5]

    Jinze Bai, Shuai Bai, Shusheng Yang, Shijie Wang, Sinan Tan, Peng Wang, Junyang Lin, Chang Zhou, and Jingren Zhou. 2023. Qwen-vl: A frontier large vision-language model with versatile abilities. arXiv preprint arXiv:2308.12966 (2023)

    arXiv 2023

  6. [6]

    Baidu. 2019. Apollo: An open autonomous driving platform. [Online]. https://github.com/ApolloAuto/apollo

    work page 2019

  7. [7]

    Alexander Carballo, David Wong, Yoshiki Ninomiya, Shinpei Kato, and Kazuya Takeda. 2019. Training engineers in autonomous driving technologies using autoware. In 2019 IEEE Intelligent Transportation Systems Conference (ITSC) . IEEE, 3347–3354

    work page 2019

  8. [8]

    H Chase. 2022. LangChain. https://github.com/langchain-ai/langchain

    work page 2022

Show all 45 references
  1. [9]

    Long Chen, Oleg Sinavski, Jan Hünermann, Alice Karnsund, An- drew James Willmott, Danny Birch, Daniel Maund, and Jamie Shotton

  2. [10]

    Anne Collin, Artur Bilka, Scott Pendleton, and Radboud Duintjer Tebbens. 2020. Safety of the intended driving behavior using rulebooks. In 2020 IEEE Intelligent Vehicles Symposium (IV) . IEEE, 136–143

    2020

  3. [11]

    Yaodong Cui, Shucheng Huang, Jiaming Zhong, Zhenan Liu, Yutong Wang, Chen Sun, Bai Li, Xiao Wang, and Amir Khajepour. 2023. Driv- ellm: Charting the path toward full autonomous driving with large language models. IEEE Transactions on Intelligent Vehicles (2023)

    2023

  4. [12]

    Thierry Deruyttere, Simon Vandenhende, Dusan Grujicic, Luc Van Gool, and Marie-Francine Moens. 2019. Talk2car: Taking control of your self-driving car. arXiv preprint arXiv:1909.10838 (2019)

    2019 arXiv

  5. [13]

    Zeyu Dong, Yimin Zhu, Yansong Li, Kevin Mahon, and Yu Sun. 2024. Generalizing End-To-End Autonomous Driving In Real-World Environ- ments Using Zero-Shot LLMs. arXiv preprint arXiv:2411.14256 (2024)

    2024 arXiv

  6. [14]

    Matthijs Douze, Alexandr Guzhva, Chengqi Deng, Jeff Johnson, Gergely Szilvasy, Pierre-Emmanuel Mazaré, Maria Lomeli, Lucas Hos- seini, and Hervé Jégou. 2024. The faiss library. arXiv preprint arXiv:2401.08281 (2024)

    2024 arXiv

  7. [15]

    Wenqi Fan, Yujuan Ding, Liangbo Ning, Shijie Wang, Hengyun Li, Dawei Yin, Tat-Seng Chua, and Qing Li. 2024. A survey on rag meeting llms: Towards retrieval-augmented large language models. In Proceed- ings of the 30th ACM SIGKDD Conference on Knowledge Discovery and Data Minin...

    2024

  8. [16]

    Masoomali Fatehkia, Ji Kim Lucas, and Sanjay Chawla. 2024. T-RAG: lessons from the LLM trenches. arXiv preprint arXiv:2402.07483 (2024)

    2024 arXiv

  9. [17]

    Daniel J Fremont, Tommaso Dreossi, Shromona Ghosh, Xiangyu Yue, Alberto L Sangiovanni-Vincentelli, and Sanjit A Seshia. 2019. Scenic: a language for scenario specification and scene generation. In Proceed- ings of the 40th ACM SIGPLAN conference on programming language design ...

    2019

  10. [18]

    Daocheng Fu, Xin Li, Licheng Wen, Min Dou, Pinlong Cai, Botian Shi, and Yu Qiao. 2024. Drive like a human: Rethinking autonomous driving with large language models. In Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision . 910–919

    2024

  11. [19]

    Charlie Hewitt, Ioannis Politis, Theocharis Amanatidis, and Advait Sarkar. 2019. Assessing public perception of self-driving cars: The autonomous vehicle acceptance model. In Proceedings of the 24th in- ternational conference on intelligent user interfaces . 518–527

    2019

  12. [20]

    TIER IV. 2022. Autoware: The world’s leading open-source software project for autonomous driving. https://autoware.org/autoware- overview/

    2022

  13. [21]

    TIER IV. 20222. Autoware.Universe Documentation. https:// autowarefoundation.github.io/autoware.universe/main

  14. [22]

    TIER IV. 2023. AWSIM: End-to-End Digital Twin Simulation Platform. https://autoware.org/awsim-end-to-end-digital-twin- simulation-platform

    2023

  15. [23]

    Nikitas Karanikolas, Eirini Manga, Nikoletta Samaridi, Eleni Tousidou, and Michael Vassilakopoulos. 2023. Large language models versus natural language understanding and generation. In 27th Pan-Hellenic Conference on Progress in Computing and Informatics . 278–290

    2023

  16. [24]

    Srishti Khemka. 2021. Incident 347: Waymo Self-Driving Taxi Behaved Unexpectedly, Driving away from Support Crew. AI Incident Database, Khoa Lam (Ed.). Responsible AI Collaborative. Retrieved February 13 (2021), 2023

    2021

  17. [25]

    Patrick Lewis, Ethan Perez, Aleksandra Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Küttler, Mike Lewis, Wen-tau Yih, Tim Rocktäschel, et al . 2020. Retrieval-augmented generation for knowledge-intensive nlp tasks. Advances in Neural Information Processing ...

    2020

  18. [26]

    You Lu, Yifan Tian, Yuyang Bi, Bihuan Chen, and Xin Peng. 2024. DiaVio: LLM-Empowered Diagnosis of Safety Violations in ADS Sim- ulation Testing. In Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis . 376–388

    2024

  19. [27]

    Steven Macenski, Tully Foote, Brian Gerkey, Chris Lalancette, and William Woodall. 2022. Robot operating system 2: Design, architecture, and uses in the wild. Science robotics 7, 66 (2022), eabm6074

    2022

  20. [28]

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

    2020 arXiv

  21. [29]

    Jiageng Mao, Yuxi Qian, and et al. 2023. Gpt-driver: Learning to drive with gpt. arXiv preprint arXiv:2310.01415 (2023)

    2023 arXiv

  22. [30]

    Sean McGregor. 2018. Incident 4: Uber AV Killed Pedestrian in Arizona. AI Incident Database, Sean McGregor (Ed.). Responsible AI Collaborative. Retrieved February 13 (2018), 2023

    2018

  23. [31]

    Chenbin Pan, Burhaneddin Yaman, Tommaso Nesti, Abhirup Mallik, Alessandro G Allievi, Senem Velipasalar, and Liu Ren. 2024. VLP: Vision Language Planning for Autonomous Driving. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition

    2024

  24. [32]

    Rodrigo Queiroz, Thorsten Berger, and Krzysztof Czarnecki. 2019. GeoScenario: An open DSL for autonomous driving scenario represen- tation. In 2019 IEEE Intelligent Vehicles Symposium (IV). IEEE, 287–294. 13 Conference’17, July 2017, Washington, DC, USA Ziwei Song, Mingsong Lv...

    2019

  25. [33]

    Hao Shao, Yuxuan Hu, Letian Wang, Guanglu Song, Steven L Waslan- der, Yu Liu, and Hongsheng Li. 2024. Lmdrive: Closed-loop end-to-end driving with large language models. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition . 15120–15130

    2024

  26. [34]

    SP Sharan, Francesco Pittaluga, Manmohan Chandraker, et al. 2023. Llm-assist: Enhancing closed-loop planning with language-based rea- soning. arXiv preprint arXiv:2401.00125 (2023)

    2023 arXiv

  27. [35]

    Junhong Shen, Neil Tenenholtz, James Brian Hall, David Alvarez-Melis, and Nicolo Fusi. 2024. Tag-LLM: Repurposing General-Purpose LLMs for Specialized Domains. arXiv preprint arXiv:2402.05140 (2024)

    2024 arXiv

  28. [36]

    Yang Sun, Christopher M Poskitt, Jun Sun, Yuqi Chen, and Zijiang Yang. 2022. LawBreaker: An approach for specifying traffic laws and fuzzing autonomous vehicles. In Proceedings of the 37th IEEE/ACM International Conference on Automated Software Engineering . 1–12

    2022

  29. [37]

    Yang Sun, Christopher M Poskitt, Xiaodong Zhang, and Jun Sun. 2024. REDriver: Runtime Enforcement for Autonomous Vehicles. In Pro- ceedings of the IEEE/ACM 46th International Conference on Software Engineering. 1–12

    2024

  30. [38]

    Bailin Wang, Zi Wang, Xuezhi Wang, Yuan Cao, Rif A Saurous, and Yoon Kim. 2024. Grammar prompting for domain-specific language generation with large language models.Advances in Neural Information Processing Systems 36 (2024)

    2024

  31. [39]

    Kun Wang, Christopher M Poskitt, Yang Sun, Jun Sun, Jingyi Wang, Peng Cheng, and Jiming Chen. 2024. 𝑚𝑢 Drive: User-Controlled Au- tonomous Driving. arXiv preprint arXiv:2407.13201 (2024)

    2024 arXiv

  32. [40]

    Shiyi Wang, Yuxuan Zhu, Zhiheng Li, Yutong Wang, Li Li, and Zheng- bing He. 2023. ChatGPT as your vehicle co-pilot: An initial attempt. IEEE Transactions on Intelligent Vehicles (2023)

    2023

  33. [41]

    Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Fei Xia, Ed Chi, Quoc V Le, Denny Zhou, et al. 2022. Chain-of-thought prompt- ing elicits reasoning in large language models. Advances in neural information processing systems 35 (2022), 24824–24837

    2022

  34. [42]

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

    2024

  35. [43]

    Zhenjie Yang, Xiaosong Jia, Hongyang Li, and Junchi Yan. 2023. Llm4drive: A survey of large language models for autonomous driving. In NeurIPS 2024 Workshop on Open-World Agents

    2023

  36. [44]

    Zirui Zang, Renukanandan Tumu, Johannes Betz, Hongrui Zheng, and Rahul Mangharam. 2022. Winning the 3rd Japan automotive AI challenge-Autonomous racing with the Autoware. auto open source software stack. In 2022 IEEE Intelligent Vehicles Symposium (IV) . IEEE, 1757–1764. 14

    2022

  37. [2024]

    In 2024 IEEE International Conference on Robotics and Automation (ICRA)

    Driving with llms: Fusing object-level vector modality for ex- plainable autonomous driving. In 2024 IEEE International Conference on Robotics and Automation (ICRA) . IEEE, 14093–14100

    2024

Pith tools

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