A multi-agent-based large language model (LLM) workflow designed to support requirement extraction from technical specifications and regulatory documents in compliance with automotive requirement guidelines is presented.
Abstract
The increasing regulatory complexity in automotive development places significant pressure on engineering teams to derive complete and correct requirements. This paper presents a multi-agent-based large language model (LLM) workflow designed to support requirement extraction from technical specifications and regulatory documents in compliance with automotive requirement guidelines. The approach structures the requirement derivation process across collaborating agents that interpret specification and regulatory text, generate candidate requirements for the early engineering activities, and cross-validate their outputs to improve consistency and traceability. To evaluate the applicability of the workflow in an industrial context, we applied it to the draft Euro 7 emissions regulation. The agents produced requirements for relevant functional domains, which were subsequently reviewed by domain experts at FEV. The evaluation focused on correctness, completeness, and coverage. Results indicate that the agentic workflow can achieve high alignment with expert expectations, demonstrates robust coverage of regulatory intent, and reduces manual effort in the early requirements engineering phase. The findings highlight the potential of structured multi-agent LLM systems to accelerate compliant software development processes and to enhance the reproducibility and quality of regulatory requirement interpretation in the automotive domain.
The results indicate that language-model assistance can add value in regulated automotive requirements workflows when it is embedded in deterministic, provenance-rich, and expert-governed processes.
A multi-agent large language model (LLM) framework tailored for automotive model-based software development that advances generative AI from isolated prompting to automation in complex development environments and sets a foundation for scalable AI-driven software pipelines in model-based systems engineering.
Abdelrahman Abdalla, Vincent Thie, Joschka Schaub et al.· IEEE Access· 1 citation
Software complexity is a long-standing challenge for system engineers. Model-Driven Engineering (MDE) addresses it by treating models as first-class artefacts, but a typical MDE process spans many tools and produces heterogeneous models of different system aspects, making traceability, maintenance, and change management difficult. We propose RADIANT, an engineering methodology that combines MDE with Multi-Agent Large Language Models (LLMs) for complete model-based system development, with a focus on safety-critical systems. From a carefully specified requirement model, RADIANT automatically generates heterogeneous models across engineering phases -- a concept model, a domain-specific modelling language, a conforming system model, and a behaviour model -- together with executable, element-level traceability links, on top of which it provides exact, automated change-impact analysis. Generated behaviour models are translated into CSP and formally verified (e.g.\ for deadlock freedom and convergence) with a counterexample-driven repair loop. Evaluating RADIANT across three LLMs, we find that the multi-agent decomposition reliably improves the \emph{syntactic validity} of the generated formal artefacts over a single-agent baseline -- and their \emph{executability} where the model's code generation permits -- while gains in semantic accuracy are model-dependent. A six-participant study shows an order-of-magnitude ($10$--$15\times$) reduction in development time, and the unmodified pipeline transfers to a second domain.
Ran Wei, Letian Zhu, Haochi Wang et al.· 0 citations
Creating code specifications is a crucial measure to improve the trustworthiness of many industrial systems implemented in Rust with high security requirements. Because writing specifications requires highly specialized professionals and is time-consuming, the automatic generation of specifications, enabled by large language models (LLMs), has received increasing attention and shown promising results. However, these methods typically focus on partial specification generation (generating proofs after the contract is known) and on extracting dependencies between code modules using predefined relations. This is not suitable for real-world industrial systems where the goal is to generate complete specifications from scratch and where the complex dependencies between code modules are variable. To address this, we propose a multi-agent collaborative framework, StarVerus, to automate the verification of industrial Rust code. Specifically, StarVerus addresses the aforementioned limitations in two ways: 1) In the generation phase, it instructs the LLM to generate all specifications for a given code, and in the repair phase, it uses a cascaded two-stage process of contract alignment and proof repair to correct them; 2) In both the generation and repair phases, it utilizes a function call graph to adaptively obtain bidirectional contextual information (i.e., what it calls and what calls it) for each code module as an additional information source for the LLM. Furthermore, StarVerus introduces a planner-repairer-actor-rewriter multi-agent paradigm to further enhance the proof repair capabilities. Finally, the effectiveness of StarVerus is validated through experiments on benchmark datasets and deployment in a real operating system.
Chao Jiang, Ding Wang, Dugang Liu et al.· Proceedings of the 32nd ACM...· 0 citations
This work proposes TraceDev, a multi-agent framework for automated software development grounded in use cases that contain multiple functional points and complex semantics, and demonstrates the effectiveness of TraceDev in repository-level code generation from requirements.
Mingyu Chen, Yakun Zhang, Zihao Xie et al.· 0 citations
Evaluated on real-world system-level requirements documents, comprising more than 720 requirements and 72 use cases, the approach generates system-level diagrams comparable to those created by experts and provides valuable architectural recommendations.
Bastian Franze, Dominik Fuchß, Friedrich Wattenberg et al.· 0 citations