betaFeedback

WorksComputer Science

REINS: A Self-Evolving Agent Harness for Real-Time Trajectory Planning

Abstract

Agent harnesses – runtime scaffolds that wrap an LLM's reasoning loop with tool dispatch, verification, and persistent memory – have become the standard substrate for deploying LLMs as autonomous agents, as demonstrated by Claude Code and Codex in software engineering. In trajectory planning, however, this paradigm has not taken hold: existing LLM-based trajectory planning methods either keep the LLM in the decision loop, exceeding the millisecond-level control budget, or offload it to offline rules or training-time supervision – leaving the runtime planner non-evolving. Intermediate hybrids still lack the verification-and-consolidation loop that makes harnesses reliable. We ask: what runtime harness would let an LLM planner meet real-time constraints while self-evolving into a deployable one? We propose REINS, a harness built on three LLM-planner couplings: LLM outputs are (i) grounded to a learned variable-level dynamics model, (ii) verified via calibrated predicates and forward rollout, and (iii) consolidated into an indexed rule memory that serves future scenes in O(log n) without re-invoking the LLM. The harness closes a self-evolution loop: familiar scenes resolve by memory lookup; novel scenes invoke the LLM, whose verified outputs enrich the memory. Without modifying LLM weights, REINS attains 98%+ compliance, nearly 50% collision reduction, and 1.9-4.6 ms latency on simulated and real-world benchmarks at the tactical decision layer, with LLM invocation rate monotonically declining as memory matures. Code: https://github.com/ZhihongCui/REINS

Introduction

Trajectory planning is the safety-critical core of autonomous driving: each decision must respect traffic rules, anticipate other agents, and complete within a millisecond-level control budget (e.g., 50 ms at 20 Hz) [45, 7, 18, 21, 31]. Recent work shows that large language models (LLMs) bring rich semantic priors over traffic norms, agent intent, and safety reasoning that classical planners lack [28, 9, 29, 35, 3, 20], yet integrating their reasoning into the runtime loop is bottlenecked: each LLM query takes seconds—orders of magnitude over the control budget—and naive integration leaves the planner either too slow to act or unable to adapt as deployment proceeds.

This is precisely the kind of deployment problem—running a stochastic LLM inside a low-latency, safety-sensitive loop—that the agent harness paradigm has recently addressed in software engineering. An agent harness wraps the LLM with a thin runtime layer of tool dispatch, intermediate-result verification, persistent memory, and safety enforcement—as exemplified by systems like Claude Code, Codex, and Cursor-Agent. On Terminal-Bench [30], harness design has emerged as a primary driver of ranking, with automatic harness optimization surpassing hand-engineered baselines [17]. Trajectory planning, however, is a sharp test of the paradigm: its millisecond-level control budget is much tighter than the seconds-to-minutes scale at which coding harnesses operate, and the safety stakes are higher. In this regime, the harness’s generic functions specialize into three couplings between LLM and planner, illustrated in Figure 1: when an LLM suggests “keep a safe distance” in a car-following scene, the runtime must (i) ground the suggestion to physical state variables (TTC, THW, DHW), (ii) verify the resulting maneuver via forward rollout over a multi-step horizon, and (iii) consolidate the verified maneuver into an indexed rule memory.

Three couplings an agent harness must enforce on the LLM planner

Figure 1. Three couplings an agent harness must enforce on the LLM planner, illustrated on a car-following scene with a 25-m gap. The LLM utterance “keep a safe distance” is (1) grounded to physical state variables (TTC, THW, DHW), (2) verified by forward rollout over a multi-step horizon, and (3) consolidated as an indexed rule keyed by these variables for instant reuse.

Existing LLM-based trajectory planning methods span two extremes plus intermediate hybrids, none of which constitutes a harness in the above sense: runtime invocation methods keep the LLM in the decision loop but exceed the millisecond-level budget by orders of magnitude [9, 29, 35]; offline extraction methods discard the LLM at runtime and freeze the planner against scenarios the offline corpus did not anticipate [20, 37]; and hybrid designs partially orchestrate the LLM at runtime but stop short of a full harness, lacking explicit verification of LLM commitments and consolidation of verified ones into reusable structure [6, 47]. Across all three, the LLM’s reasoning is either too slow to act on or too detached from the loop to evolve with deployment.

This raises our central question: what runtime harness would let an LLM planner satisfy real-time constraints while self-evolving into a deployable one? Each of the three couplings is nontrivial under real-time control: grounding requires bridging natural-language commitments to the planner’s threshold semantics [41, 44]; verification must catch stochastic, occasionally unsafe LLM outputs before they reach control [28, 43]; and consolidation must escape per-call LLM latency [9, 29] via a memory pattern emerging in agentic AI [40, 48, 26] but not yet transferred to real-time planning. The three are also jointly necessary: without grounding, verification has nothing to check; without verification, consolidation stores unverified content; without consolidation, every scene re-pays the LLM latency cost. When all three are addressed, a self-evolution loop emerges: familiar scenes resolve from the consolidated memory in O(log⁡n)O(\log n) time, novel scenes invoke the LLM, whose verified outputs enrich the memory, and reliance on the LLM decreases monotonically as memory matures, with no LLM weight update.

We propose REINS, a concrete realization of this harness pattern, instantiated for trajectory planning in driving, that addresses each coupling as follows. Grounding. We learn a world dynamics model over a factored variable space, fusing LLM-derived semantic priors with data-driven dependency discovery. Group-weighted ridge regression selects each variable’s parents, and a per-variable Transformer predicts its evolution under the discovered graph. Every LLM output can then be projected onto this variable space and rolled out under the learned dynamics. Verification. We compile each LLM-proposed maneuver into calibrated predicates with thresholds derived from data (z-score, quantile, or absolute). Predicates are evaluated against the rollout produced by the dynamics model, and only commitments whose predicted trajectory satisfies all guards are released to control. Hallucinated or unsafe commitments are filtered before any maneuver is issued. Consolidation. We persist verified commitments in an indexed rule memory backed by a graph database, keyed by the grounding variables that triggered them. At runtime, parameterized graph queries retrieve scene-relevant rules in O(log⁡n)O(\log n) time without any LLM call. Recurring scenes are thus served by memory lookup, and the LLM is invoked only on a miss. Together, the three close the self-evolution loop: at each scene the planner first consults the memory; on a miss the LLM is invoked, its output grounded against the dynamics model, verified by rollout, and—if it passes—committed to memory for the next encounter. We provide an empirical demonstration that, under such a harness, an LLM planner monotonically reduces its own LLM-call rate while preserving safety and compliance. Our contributions can be summarized as:

  • We extend the agent-harness paradigm to real-time trajectory planning, identifying three couplings—grounding, verification, consolidation—any such harness must enforce, and instantiate it for driving; only the variable schema and the action space are domain-specific (Appendix D.1).

  • We design REINS, a harness that instantiates the three couplings via a learned world dynamics model, calibrated predicates with rollout verification, and an indexed rule memory.

  • We provide the first empirical evidence of self-evolution in real-time LLM trajectory planning: LLM invocation rate decreases monotonically over deployment with no LLM weight update.

  • We evaluate REINS on simulated and real-world driving benchmarks at the tactical decision layer, achieving 98%+ compliance, nearly 50% collision reduction, and 1.9–4.6 ms planning latency—well within the real-time control budget.

Related Work

LLM-Based Trajectory Planning. Recent LLM-based trajectory planners fall along three lines, each realizing some couplings while leaving others open. Runtime invocation methods keep the LLM in the decision loop. DiLu [9] pairs LLM reasoning with an experience-replay memory; Agent-Driver [29] treats the LLM as an orchestrator over perception and planning tools; LanguageMPC [35] feeds chain-of-thought outputs into MPC. These systems gain semantic flexibility, but each LLM query takes seconds, and any output that reaches the planner is implicitly trusted, lacking the calibrated checks proposed for stochastic LLM outputs in safety-critical settings [28, 43].

Offline extraction methods sit at the opposite end. LLaDA [20] extracts location-specific rules from driver handbooks, DriReg [3] retrieves regulatory text via RAG, and Plan-R1 [37] distills LLM-shaped rewards into a reinforcement-learning policy. Removing the LLM at runtime buys real-time inference, but the planner becomes static, unable to consolidate new commitments against learned driving dynamics [41, 44] or to adapt to scenarios the offline corpus did not anticipate.

Hybrid designs partially orchestrate the LLM at runtime. C-TRAIL [6] runs a closed-loop Recall–Plan–Update cycle with trust-weighted MCTS injection; LeAD [47] pairs an end-to-end planner with a redundant LLM reasoning track. These improve over either extreme but lack explicit verification of LLM commitments and consolidation of those ones into reusable structure; none grounds, verifies, and consolidates LLM outputs jointly under a real-time harness.

Agent Harnesses for LLM Deployment. Outside trajectory planning, the deployment of LLMs into real-world tasks has converged on the agent harness pattern: a thin runtime layer that wraps the LLM with tool dispatch, intermediate-result verification, persistent memory, and safety enforcement. In autonomous coding, systems such as Claude Code and Codex turn general-purpose LLMs into reliable software engineers, and harness design has become a primary driver of ranking on Terminal-Bench [30, 17]. In open-ended decision-making, Voyager [40] accumulates a skill library of executable code through curiosity-driven exploration; Eureka [26] iteratively refines reward functions by evolutionary search over LLM proposals; ExpeL [48] distills task-specific experience into a retrievable knowledge base. These harnesses share three structural elements with REINS—grounding into a domain. primitive space, verification of LLM outputs, and persistent reuse of verified ones—but none operate under millisecond real-time budgets nor expose their LLMs to the safety-critical constraints.

Preliminaries

We formalize the harness’s primitives: a factored variable space (§ 3.1); a world dynamics model for grounding (§ 3.2); an executable rule representation for verification and consolidation (§ 3.3); and the problem definition (§ 3.4). Full variable lists, template specifications, and the macro-group dependency enumeration appear in Appendix § 9.

Driving Environment

Definition 3.1 (Factored Variable Structure). A factored variable structure is (X,H,EG,EH)(\mathcal{X}, \mathcal{H}, \mathcal{E}_{\mathcal{G}}, \mathcal{E}_{\mathcal{H}}): X={X1,…,Xd}\mathcal{X} = \{X_1,\ldots,X_d\} are observable variables (e.g., TTC, THW, DHW, ego_speed, lead_speed, road_friction); H={ENV,TRAFFIC,EGO,ACTION,OUTCOME}\mathcal{H} = \{\mathrm{ENV},\mathrm{TRAFFIC},\mathrm{EGO},\mathrm{ACTION},\mathrm{OUTCOME}\} groups them by semantic role [4]; EG⊆X×H\mathcal{E}_{\mathcal{G}} \subseteq\mathcal{X} \times\mathcal{H} assigns each variable to a group; and EH⊆H×H\mathcal{E}_{\mathcal{H}} \subseteq\mathcal{H} \times\mathcal{H} specifies permissible group-level dependencies (Eq. (10) in Appendix § 9.§ 1).

Definition 3.2 (State and Action Spaces). The state st∈S=∏idom⁡(Xi)s_t \in\mathcal{S} = \prod_i \operatorname{dom}(X_i) is a complete variable assignment. The action space A={LANE_LEFT,LANE_RIGHT,FASTER,SLOWER,IDLE}\mathcal{A} = \{\mathrm{LANE\_LEFT}, \mathrm{LANE\_RIGHT}, \mathrm{FASTER}, \mathrm{SLOWER}, \mathrm{IDLE}\} is a finite set of discrete meta-actions for the ego vehicle.

The meta-actions are the interface of the tactical (behavior-planning) layer in the standard stack decomposition [32]; continuous low-level controllers execute them, and all safety reasoning below (TTC, headway, accelerations) remains continuous.

World Dynamics Model

Definition 3.3 (Dependency Graph and Dynamics). A dependency graph is a weighted DAG G=(X,E,w)\mathcal{G} = (\mathcal{X}, \mathcal{E}, w) with w:E→Rw : \mathcal{E} \to\mathbb{R}, where edges (Xi,Xj)∈E(X_i, X_j) \in\mathcal{E} are admissible only if (h(Xi),h(Xj))∈EH(h(X_i), h(X_j)) \in\mathcal{E}_{\mathcal{H}} [11]. A dynamics function set F={fi}i=1d\mathcal{F} = \{f_i\}_{i=1}^{d} predicts each variable from its parents over a temporal lag LL [33]:

X^it+1=fi(Pa⁡(Xi)t−L+1:t),Pa⁡(Xi)={Xj∣(Xj,Xi)∈E}.(1)\widehat{X}_i^{t+1} = f_i\left(\operatorname{Pa}(X_i)^{t-L+1:t}\right), \quad\operatorname{Pa}(X_i) = \{X_j \mid(X_j, X_i) \in\mathcal{E}\}. \tag*{(1)}

An HH-step rollout from sts_t under (at,…,at+H−1)(a_t,\ldots,a_{t+H-1}) yields ξ^=(s^t+1,…,s^t+H)\widehat{\xi} = (\widehat{s}_{t+1},\ldots,\widehat{s}_{t+H}).

Rule Representation

Definition 3.4 (Predicate). A predicate is a Boolean function p(s)=I[s[Xi]≺τ]p(s) = \mathbb{I}[s[X_i] \prec\tau] with comparison operator ≺∈{<,>,≤,≥}\prec\in\{<, >, \leq, \geq\} and threshold τ∈R\tau\in\mathbb{R}.

TTC and THW guards are the surrogate safety measures of traffic engineering [10]; their calibrated thresholds act as RSS-style safe-distance bounds [36].

Definition 3.5 (Rule Template). A rule template TT specifies how predicates compose [27]. We use seven templates: IF-THEN, AND-THEN, THRESHOLD, PRIORITY, MULTI-ACTION, WEIGHTED-ACTION, and TEMPORAL-CHAIN (specifications and examples in Appendix § 9.§ 2).

Definition 3.6 (Executable Rule). An executable rule is a tuple r=(T,Pr,ar,cr)r = (T, \mathcal{P}_r, a_r, c_r) with template TT, guard predicates Pr\mathcal{P}_r, recommended action ar∈Aa_r \in\mathcal{A}, and confidence cr∈[0,1]c_r \in[0,1]. Activation requires all guards to hold:

Exec⁡(r,st)=⋀p∈Prp(st).(2)\operatorname{Exec}(r,s_t) = \bigwedge_{p \in\mathcal{P}_r} p(s_t). \tag*{(2)}

Problem Definition

Definition 3.7 (Self-Evolving Agent Harness for Trajectory Planning). Let D={(st,at,st+1)}\mathcal{D} = \{(s_t, a_t, s_{t+1})\} be a driving dataset and M\mathcal{M} a pre-trained LLM. The harness problem is to construct (G^,F^,R,π)(\widehat{\mathcal{G}}, \widehat{\mathcal{F}}, \mathcal{R}, \pi), where G^,F^\widehat{\mathcal{G}}, \widehat{\mathcal{F}} are learned from D\mathcal{D} with priors from M\mathcal{M} (Def. 3.3), R\mathcal{R} is an indexed rule memory compiled offline from M\mathcal{M} (Def. 3.6), and π:S→A\pi: \mathcal{S} \to\mathcal{A} is a policy that, at each sts_t, retrieves Rt=Retrieve⁡(st,R)⊆R\mathcal{R}_t = \operatorname{Retrieve}(s_t,\mathcal{R}) \subseteq\mathcal{R} and proceeds as follows:

  • (hit) if Rt≠∅\mathcal{R}_t \ne\varnothing, π\pi scores actions over Rt\mathcal{R}_t and verifies them by rollout under F^\hat{F} within a real-time budget;

  • (miss) otherwise, M\mathcal{M} proposes a candidate commitment, which is grounded via (G^,F^)(\hat{G}, \hat{F}) and verified by rollout; if all predicates pass, the commitment is compiled into a rule rr and R←R∪{r}\mathcal{R} \leftarrow\mathcal{R} \cup\{r\}.

The parameters of M\mathcal{M} remain unchanged, and R\mathcal{R} is monotone non-decreasing; under stationarity of the scene distribution, the per-scene LLM invocation rate Pr⁡[Rt=∅]\Pr[\mathcal{R}_t = \varnothing] is non-increasing.

Methodology

REINS realizes the harness as a two-phase system (Figure 2). Offline Preparation (§ 4.1) prepares the world dynamics G^,F^\hat{G}, \hat{F} for grounding and an initial rule memory R0\mathcal{R}_0 for offline consolidation. Online Runtime (§ 4.2) executes a per-scene loop: rule-guided planning performs retrieval, scoring, and verification over R\mathcal{R}, and online rule acquisition handles memory misses by querying M\mathcal{M} and writing verified rules back to R\mathcal{R}, closing the self-evolution loop.

The REINS framework

Figure 2. The REINS framework. Phase 1 (offline): learn dynamics G^\hat{G}, F^\hat{F} and compile rules into initial memory R0\mathcal{R}_0. Phase 2 (online): per-scene retrieval and rollout-based verification produce control; on a miss, the LLM proposes a rule that is grounded, verified, and written back to R\mathcal{R}, closing the self-evolution loop without any LLM weight update.

Offline Preparation

World Dynamics Learning

This module realizes grounding: we jointly learn dependency graph G^\hat{G} and dynamics functions F^\hat{F} by combining LLM semantic priors with data-driven structure discovery. The full derivation and the dynamics loss are in Appendix § 9.§ 4.1.

Dependency Graph. The LLM provides edge confidence πij∈[0,1]\pi_{ij} \in[0,1] for each candidate edge Xj→XiX_j \to X_i (Appendix § 9.§ 5); combined with macro-group constraints (Eq. (10)), the unified prior is π~ij=απij+(1−α)I{(h(Xj),h(Xi))∈EH}\tilde{\pi}_{ij} = \alpha\pi_{ij} + (1-\alpha)\mathbb{I}\{(h(X_j),h(X_i)) \in E_{\mathcal{H}}\}. For each XiX_i, prior-guided ridge regression [13] predicts its value from lagged neighbors with adaptive penalty λij=λ0(1−π~ij)ρ\lambda_{ij} = \lambda_0(1-\tilde{\pi}_{ij})^\rho, so high-prior edges are weakly regularized:

w^i=arg⁡min⁡w∑t=1N(Xit−∑j≠i,ℓwjℓXjt−ℓ)2+∑j≠iλij∥wj∥22.(3)\hat{\mathbf{w}}_i = \arg\min_{\mathbf{w}} \sum_{t=1}^{N}\left(X_i^t-\sum_{j\ne i,\ell}w_{j\ell}X_j^{t-\ell}\right)^2+\sum_{j\ne i}\lambda_{ij}\lVert\mathbf{w}_j\rVert_2^2. \tag*{(3)}

Pa⁡(Xi)\operatorname{Pa}(X_i) retains the top-KK variables by ∑ℓ∣w^jℓ∣\sum_{\ell}|\hat{w}_{j\ell}|, yielding E^\hat{E} and weights w^(Xj,Xi)=∑ℓ∣w^jℓ∣\hat{w}(X_j,X_i)=\sum_{\ell}|\hat{w}_{j\ell}|.

Dynamics Functions. Given G^\hat{G}, each fif_i is a multi-head Transformer [39] trained to predict Xit+1X_i^{t+1} from Pa⁡(Xi)t−L+1:t\operatorname{Pa}(X_i)_{t-L+1:t} via mean squared error (loss form in Eq. (14)). Training curves and hyperparameters are in Appendix § 11.§ 1.

Rule Compilation

This module realizes offline consolidation: compiling LLM knowledge into executable rules. Full equations and per-step prose are in Appendix § 9.§ 4.2.

Rule Structure Generation. For each edge (Xj,Xi)∈E^(X_j, X_i) \in\hat{E}, the LLM generates a rule r=(T,Pr,ar,cr)r = (T, P_r, a_r, c_r) (Eq. (15)) with template TT (Def. 3.5), guard predicates PrP_r with symbolic thresholds, recommended action ar∈Aa_r \in\mathcal{A}, and confidence crc_r derived from edge weight w^(Xj,Xi)\hat{w}(X_j, X_i) (prompts in Appendix § 9.§ 5).

Threshold Calibration. Each predicate’s threshold τi\tau_i is calibrated from D\mathcal{D} in three forms [25]—zz-score μi+ζσi\mu_i + \zeta\sigma_i, quantile Qi(ζ)Q_i(\zeta), or absolute constant τ0\tau_0—and the comparison operator ≺\prec is selected to maximize separability of safety outcome y∈{0,1}y \in\{0, 1\}:

≺∗=arg⁡max⁡≺∈{<,>} ∣E[y∣Xi≺τi]−E[y∣Xi⊀τi]∣.(4)\prec^* = \underset{\prec\in\{<,>\}}{\arg\max}\ \left|\mathbb{E}[y \mid X_i \prec\tau_i] - \mathbb{E}[y \mid X_i \not\prec\tau_i]\right|. \tag*{(4)}

Rule activation then follows Eq. (2).

Graph Database Storage. Compiled rules are stored in a Neo4j graph database [42] with rule nodes connected to variable nodes via TRIGGERS (input) and AFFECTS (output) edges, enabling O(log⁡∣R∣)O(\log|\mathcal{R}|) retrieval. The full schema (Figure 3) is in Appendix § 9.§ 4.2; database statistics are in Appendix § 11.7.1.

Figure 3. Rule database schema.

Online Runtime

Rule-Guided Planning

This module realizes the runtime planning loop of Def. 3.7—retrieval, scoring, and verification (details in Appendix § 9.4.3).

Scene-Aware Retrieval. Given sts_t, active variables {Xi}\{X_i\} trigger parameterized Cypher queries [8] generated by the LLM (read-only, schema-constrained; Appendix § 9.§ 5). The retrieval map G:({Xi},K)↦Rt⊆RG : (\{X_i\}, K) \mapsto\mathcal{R}_t \subseteq\mathcal{R} (Eq. (17)) returns up to KK rules ranked by confidence, restricted to triggers whose dependency direction respects the macro-group constraints.

Action Scoring. For each r∈Rtr \in\mathcal{R}_t activated via Eq. (2), a Transformer-based scorer [22] produces relevance Srel(r,st)∈[0,1]S_{\mathrm{rel}}(r, s_t) \in[0, 1] and action preference Sact(r,st,a)S_{\mathrm{act}}(r, s_t, a), yielding combined score f(r,a∣st)=Srel⋅Sact⋅crf(r, a \mid s_t) = S_{\mathrm{rel}} \cdot S_{\mathrm{act}} \cdot c_r (Eqs. (18)–(19); training loss in Eq. (20)). Multiple rules recommending action aa, denoted Rt(a)={r∈Rt∣ar=a}\mathcal{R}_t(a) = \{r \in\mathcal{R}_t \mid a_r = a\}, are aggregated by noisy-OR:

P(a∣st)∝1−∏r∈Rt(a)(1−f(r,a∣st)).(5)P(a \mid s_t) \propto1 - \prod_{r \in\mathcal{R}_t(a)} (1 - f(r, a \mid s_t)). \tag*{(5)}

The full normalized form and argmax decoder are in Appendix § 9.4.3.

Trajectory Verification. The learned dynamics F^\hat{F} verifies safety via forward rollout. For the top-MM actions ranked by P(a∣st)P(a \mid s_t), we predict HH-step trajectories ξ^(a)=(s^t+1,…,s^t+H)\hat{\xi}(a) = (\hat{s}_{t+1}, \ldots, \hat{s}_{t+H}) via s^t+H=Φ(s^t+h,a;G^,F^)\hat{s}_{t+H} = \Phi(\hat{s}_{t+h}, a; \hat{G}, \hat{F}) (Eq. (22)), and select at∗=arg⁡max⁡a∈AMJ(ξ^(a))a_t^* = \arg\max_{a \in\mathcal{A}_M} J(\hat{\xi}(a)), where JJ penalizes collisions, rule violations, and control effort (Appendix § 10.§ 2); the first control is executed in receding-horizon [46].

Online Rule Acquisition

This module realizes Def. 3.7’s miss-handling path through four steps (full equations and the monotonicity argument in Appendix § 9.4.4).

Miss Detection. We operationalize the miss criterion (Rt=∅)(\mathcal{R}_t = \varnothing) with an additional confidence guard against weakly supported matches:

Miss⁡(st)=I[Rt=∅]∨I[max⁡r∈Rt, a∈Af(r,a∣st)<η],(6)\operatorname{Miss}(s_t) = \mathbb{I}[\mathcal{R}_t = \varnothing] \lor\mathbb{I}\left[\max_{r \in\mathcal{R}_t,\,a \in\mathcal{A}} f(r, a \mid s_t) < \eta\right], \tag*{(6)}

with tuned threshold η∈(0,1)\eta\in(0,1).

Rule Proposal and Online Verification. On a miss, M\mathcal{M} proposes r~=(T~,P~,a~,c~)\tilde{r}=(\tilde{T},\tilde{\mathcal{P}},\tilde{a},\tilde{c}) (Eq. (23)) conforming to Defs. 3.4–3.5 (Appendix § 9.§ 5). Symbolic thresholds in P~\tilde{\mathcal{P}} are calibrated on a sliding window DtW={st−W+1,…,st}\mathcal{D}^{W}_{t}=\{s_{t-W+1},\ldots,s_t\} so they track the current distribution. The harness then rolls out a~\tilde{a} from sts_t under F^\hat{F} and accepts r~\tilde{r} iff every predicate holds along the rollout:

Accept⁡(r~,st)=⋀p∈P~⋀h=1Hp(s^t+h).(7)\operatorname{Accept}(\tilde{r},s_t)=\bigwedge_{p\in\tilde{\mathcal{P}}}\bigwedge_{h=1}^{H}p(\hat{s}_{t+h}). \tag*{(7)}

On rejection the planner falls back to arg⁡max⁡aP(a∣st)\arg\max_a P(a\mid s_t) over Rt\mathcal{R}_t if Rt≠∅\mathcal{R}_t\ne\varnothing; otherwise the harness raises a human-takeover alert and executes the safest action under F^\hat{F} by maximizing minimum lookahead TTC (Eq. (24) in Appendix § 9.4.4).

Memory Update. Accepted r~\tilde{r} is keyed by content hash κ(r~):=κ(T~,P~,a~)\kappa(\tilde{r}):=\kappa(\tilde{T},\tilde{\mathcal{P}},\tilde{a}) and inserted into Neo4j; on collision, confidences are averaged instead of duplicating the node:

R⟵{R∪{r~}κ(r~)∉Keys⁡(R),R with cr′←12(cr′+c~)∃r′∈R:κ(r′)=κ(r~).(8)\mathcal{R}\longleftarrow \begin{cases} \mathcal{R}\cup\{\tilde{r}\} & \kappa(\tilde{r})\notin\operatorname{Keys}(\mathcal{R}),\\ \mathcal{R}\text{ with }c_{r'}\leftarrow\frac{1}{2}(c_{r'}+\tilde{c}) & \exists r'\in\mathcal{R}:\kappa(r')=\kappa(\tilde{r}). \end{cases} \tag*{(8)}

The collision-branch rationale (averaging vs. duplication, exclusion of c~\tilde{c} from κ\kappa) is in Appendix § 9.4.4.

Self-Evolution Properties. Eq. (8) structurally enforces ∣Rt+1∣≥∣Rt∣\lvert\mathcal{R}_{t+1}\rvert\ge\lvert\mathcal{R}_t\rvert (memory monotonicity) and θM≡θM(0)\theta_{\mathcal{M}}\equiv\theta_{\mathcal{M}}^{(0)} (no LLM update). Under stationarity of the scene distribution, the per-state miss rate is non-increasing as R\mathcal{R} accumulates coverage:

∣Rt+1∣≥∣Rt∣,Pr⁡[Miss⁡(st+1)]≤Pr⁡[Miss⁡(st)],θM≡θM(0).(9)\lvert\mathcal{R}_{t+1}\rvert\ge\lvert\mathcal{R}_t\rvert,\quad\Pr[\operatorname{Miss}(s_{t+1})]\le\Pr[\operatorname{Miss}(s_t)],\quad\theta_{\mathcal{M}}\equiv\theta_{\mathcal{M}}^{(0)}. \tag*{(9)}

so the per-scene LLM invocation rate decays monotonically with Pr⁡[Miss⁡]\Pr[\operatorname{Miss}] (full argument in Appendix § 9.4.4; validated in § 5.4).

Experiment

The main body reports overall comparison (§ 5.2), ablation (§ 5.3), self-evolution dynamics on Highway (§ 5.4), and a summary of the robustness, transfer, and scalability results. Appendices C and D report trajectory accuracy, sensitivity, extended self-evolution traces, a case study, the rule database, and the fairness and robustness studies.

Experiment Setting

Datasets and Protocols. We evaluate REINS on four highway-env [19] scenarios—Highway, Merge, Roundabout, Intersection (100 steps at 5 Hz, 15 observable vehicles per episode)—and two drone-captured real-world datasets [15, 16]: highD (German highway, 4,237 vehicles, 578 lane changes) and rounD (German roundabouts, 2,156 vehicles, 423 yield/merge events). Surrounding vehicles in simulation are reactive (IDM car-following [38] with MOBIL lane changes [14]), so they brake, yield, and change lanes in response to the ego. The real-world datasets run in closed-loop replay: one recorded vehicle is controlled by the planner while the others follow their recorded trajectories, so these rows reflect human behavior rather than a simulator’s; a collision is registered when bounding boxes overlap or the ego leaves the drivable lane. A reactive-replay variant following the nuPlan protocol [2] is in Appendix § 12.§ 6. All methods observe clean factored variables; perception, tracking, and map errors lie outside the evaluated system (§ 6).

Evaluation Metrics. Compl. (Rule Compliance) is the fraction of steps at which all active rules hold, measured for each method against its own executable rule set; an audit of all methods against REINS’s compiled set as a common reference leaves the ordering unchanged (Appendix § 12.§ 2). RE (Risk-aware Efficiency) is task reward minus a TTC-based risk penalty. CR (Collision Rate) is the fraction of episodes with at least one contact among the 15 vehicles over 100 steps, an episode-level rate in deliberately stressed traffic. PE (Planning Efficiency) is the mean wall-clock ms of the synchronous action-selection computation per step for every method; for REINS it excludes the asynchronous rule-acquisition pipeline, profiled separately in Appendix § 12.8. TTC and THW, which underlie the guards and the RE penalty, are the surrogate safety measures of traffic engineering [10], and Compl. and CR echo the rule-conformance and collision outcomes reported in scenario-based safety assessment [34]. Results are averaged over five seeds; formal definitions in Appendix § 10.§ 2.

Baselines. We compare with eight baselines covering the regimes from § 2 plus classical anchors: (i) classical (MPC [Falcone et al., [7]], MCTS [Lenz et al., [18]]); (ii) runtime invocation (DriveSpeak [Cui et al., [5]]); (iii) online extraction (LLaDA [Li et al., [20]], DriReg [Cai et al., [3]], Plan-R1 [Tang et al., [37]]); (iv) symbolic/hybrid (PDDL [Guan et al., [12]; Liu et al., [24]], SymAgent [Liu et al., [23]]). All methods share the observation space, action space, episodes, and LLM backbone (GPT-4o, temperature 0); descriptions, the shared and unshared conditions, and a matched re-run of PDDL and DriReg over REINS’s vocabulary and calibration pipeline are in Appendices § 10.§ 3 and § 12.§ 2.

Performance Evaluation

Performance evaluation results are reported in Table 1, with trajectory accuracy analysis in Appendix § 11.§ 2.

DatasetScenarioMetricDriveSpeakLLaDAMPCMCTSPDDLDriRegSymAgentPlan-R1REINS
SimulationHig.Compl. (↑)----0.91230.94520.95610.97170.9956
SimulationHig.RE (↑)-6.0360-5.8537-5.5613-5.2311-4.7868-4.1282-3.8662-3.56230.5228
SimulationHig.CR (↓, %)38.2835.5114.2716.7625.9321.7616.5212.835.67
SimulationHig.PE (↓, ms)5.89215.29952.47422.35914.95214.31273.96213.73912.4998
SimulationMer.Compl. (↑)----0.90110.93820.95720.96410.9924
SimulationMer.RE (↑)-5.5730-5.2621-5.3891-5.1890-4.7129-4.1067-3.5622-3.1023-0.0400
SimulationMer.CR (↓, %)35.6222.8427.9123.6421.5220.5616.8314.786.86
SimulationMer.PE (↓, ms)5.21204.36151.73541.65263.85492.81222.56972.24181.8928
SimulationRou.Compl. (↑)----0.88380.91290.94110.95680.9925
SimulationRou.RE (↑)-7.6873-7.1069-6.7722-6.5113-6.4895-6.3457-6.2313-6.0256-0.5444
SimulationRou.CR (↓, %)39.1936.6324.2721.6223.8425.1324.7418.579.01
SimulationRou.PE (↓, ms)8.26737.65414.21344.02675.37935.16825.07134.86213.6243
SimulationInt.Compl. (↑)----0.87890.91530.92740.95530.9838
SimulationInt.RE (↑)-7.9740-7.5800-7.1345-7.0273-6.9792-6.7632-6.3314-6.0322-0.5747
SimulationInt.CR (↓, %)44.2742.2225.3823.7832.1229.8925.3420.379.08
SimulationInt.PE (↓, ms)10.93249.35494.96534.75196.76826.27935.99325.57334.5807
Real-worldhighDCompl. (↑)----0.90780.92890.94230.96120.9867
Real-worldhighDRE (↑)-5.8234-5.5127-5.2891-5.0124-4.6523-4.2178-3.7856-3.45210.3847
Real-worldhighDCR (↓, %)35.2132.8718.3419.5623.1220.8917.2312.786.12
Real-worldhighDPE (↓, ms)6.12345.56722.61232.48915.12344.56234.12343.89122.6234
Real-worldrounDCompl. (↑)----0.89560.91870.93780.95340.9856
Real-worldrounDRE (↑)-7.4521-6.9834-6.5123-6.2478-6.1234-5.8912-5.6234-5.3178-0.4123
Real-worldrounDCR (↓, %)41.2338.5625.3423.1226.7824.2320.8918.479.45
Real-worldrounDPE (↓, ms)8.56217.89234.35214.12345.62345.21784.89124.56233.8912

Table 1. Performance comparison across simulated scenarios and real-world datasets. Methods without explicit rule representations (MPC, MCTS, DriveSpeak, LLaDA) cannot report Compliance against their own rules as they lack executable rule constraints; their compliance against REINS’s compiled set as a common reference is given in Table 15.

Effectiveness Analysis. (i) REINS beats all baselines, improving over Plan-R1 by 2.4%–3.6% Compl., 3.0%–5.48 RE, and 49%–56% CR reduction—validating that grounding, verification, and consolidation act jointly. (ii) All methods incur higher CR on complex scenarios (Roundabout, Intersection) than structured ones (Highway, Merge); REINS degrades least, owing to context-aware retrieval. (iii) On highD and rounD, REINS maintains Compl. above 0.98 with 6.6–9.0-point CR reduction over Plan-R1, transferring to naturalistic driving without domain-specific tuning. (iv) Executable rule methods (PDDL, DriReg, SymAgent, Plan-R1) beat language-guided ones (DriveSpeak, LLaDA, with 22%–44% CR for ungrounded rules), yet their static thresholds and uniform activation still trail REINS’s data-driven calibration and variable-indexed retrieval; a matched re-run over REINS’s vocabulary and calibration narrows PDDL’s and DriReg’s CR by 3–5 points but leaves the gap intact (Appendix § 12.§ 2). (v) Classical planners (MPC, MCTS) are fast but unsafe (CR 14%–28%); Plan-R1 is the best baseline but plateaus under uniform rule application.

Efficiency Analysis. REINS completes planning in 1.9–4.6 ms per step, up to 58% faster than runtime LLM baselines (DriveSpeak, LLaDA) and 15–33% faster than Plan-R1. Two factors contribute: (i) variable-indexed retrieval activates only 2–3 rules per step via O(log⁡∣R∣)O(\log\lvert R\rvert) queries, and (ii) learned dynamics enable closed-form rollout without iterative LLM calls. PDDL makes no runtime LLM call either, yet re-grounds every precondition at each step (3.71 of its 4.95 ms on Highway; Appendix § 12.§ 3), exactly the cost that indexed consolidation removes.

Ablation Study

We conduct ablation experiments on all four simulated scenarios to evaluate component contributions. Table 2 reports results for four variants: (i) w/o World Model: replacing learned dynamics with constant-velocity propagation; (ii) w/o LLM Prior: using purely data-driven structure learning without semantic guidance; (iii) w/o Rule Generation: substituting LLM-generated rules with hand-crafted ones; (iv) w/o Retrieval: applying all rules uniformly without context-aware selection.

Metricw/o Worldw/o LLM Priorw/o Rule Generationw/o RetrievalFull
Hig.Compl. (↑)0.95210.96280.93120.98450.9956
Hig.RE (↑)-1.9234-1.5390-2.4156-0.89210.5228
Hig.CR (↓,%)8.478.2611.238.125.67
Hig.PE (↓, ms)2.95322.68312.51243.89212.4998
Mer.Compl. (↑)0.96870.97380.91980.98120.9924
Mer.RE (↑)-1.5621-1.2619-2.1893-0.7234-0.0400
Mer.CR (↓,%)9.239.0812.878.896.86
Mer.PE (↓, ms)2.62342.18321.90212.98341.8928
Rou.Compl. (↑)0.95340.96110.90870.97560.9925
Rou.RE (↑)-2.3456-1.1783-3.1234-1.2134-0.5444
Rou.CR (↓,%)12.3411.8415.8911.239.01
Rou.PE (↓, ms)4.12453.80113.65215.21343.6243
Int.Compl. (↑)0.94560.95820.89230.96890.9838
Int.RE (↑)-2.5678-1.9812-3.4521-1.3456-0.5747
Int.CR (↓,%)13.4512.2317.5611.129.08
Int.PE (↓, ms)4.95214.72144.62346.12344.5807

Table 2. Ablation study across four driving scenarios.

Removing the world dynamics model causes the largest safety degradation (CR +49%/+48% on Highway/Intersection), confirming multi-step prediction is essential. Without LLM priors, CR rises 31–46%, showing that semantic guidance regularizes dependency discovery beyond purely data-driven methods. Hand-crafted rules yield the largest compliance drop (0.9956→0.9312 on Highway) and nearly double CR, exposing the limited coverage of manual engineering; even so, they remain safer inside the harness than every matched no-harness baseline (Appendix § 12.§ 2). Disabling context-aware retrieval raises both CR (22–43%) and PE (34–58%) via conflicting constraints. The four roles are complementary: dynamics enables predictive verification, LLM priors regularize structure, rule generation ensures coverage, and selective retrieval prevents conflicts.

Self-Evolution Analysis

We deploy REINS for 1000 episodes on Highway from the offline-compiled memory R0\mathcal{R}_0 (∣R0∣\lvert\mathcal{R}_0\rvert=88), reporting four checkpoint snapshots alongside a Frozen R0\mathcal{R}_0 control that runs the same window with acquisition disabled (Table 3; other scenarios in Appendix § 11.§ 5). Across deployment, ∣R∣\lvert\mathcal{R}\rvert grows from 88 to 145 (saturating after ep. 500, Eq. (9)), the LLM call rate decays from 70.0% to 12.81% (a 5.5× reduction with no weight update), Compl. rises from 0.9885 to 0.9956, and CR drops from 7.05% to 5.67%. Against the Frozen R0\mathcal{R}_0 control over the same horizon (0.9800 Compl., 9.63% CR), online acquisition adds +0.0156 Compl. and removes 3.96 CR points—the headline self-evolution gain.

Checkpoint∣R∣\lvert\mathcal{R} \rvertLLM Call Rate (%)Compl. (↑\uparrow)CR (%) (↓\downarrow)
ep. 25011370.00.98857.05
ep. 50012748.440.99206.11
ep. 75013825.00.99425.83
ep. 1000 (final)14512.810.99565.67
Frozen R0R_0 (1000-ep eval)88—0.98009.63

Table 3. Self-evolution dynamics on Highway over 1000 episodes; LLM call rate is the miss rate (Eq. 6) in the 250-episode window ending at each checkpoint.

Mapped to the three couplings: monotone ∣R∣\lvert\mathcal{R} \rvert under κ\kappa-hash deduplication validates consolidation, the joint Compl. ↑\uparrow/CR↓\downarrow trajectory validates rollout-based verification, and the 5.5×\times call-rate drop validates the grounding–consolidation loop, as variable-keyed memory hits replace LLM calls on similar scenes.

Of the roughly 39,000 proposals implied by these call rates, 2.1% failed schema validation, 18.0% were rejected by rollout verification, and the accepted remainder deduplicated to 57 unique rules, 54 of which an audit judged consistent with domain guidelines (Appendix § 12.§ 5).

Robustness, Transfer, and Scalability. Appendix D stresses these results. Rules regenerated with Claude Sonnet 4.5 or Qwen2.5-72B-Instruct keep Highway CR at 5.89% and 6.24% (vs. 5.67%), and prompt paraphrases span 5.58–5.91%. Under 2.5–10% observation noise and 5% frame drops, REINS CR rises to at most 8.14% while Plan-R1 rises to 19.87%. A memory compiled only from highD/rounD starts at an 86.2% call rate on highway-env and recovers to within 0.5–1.1 CR points of the native memory within 1000 episodes, whereas a frozen transferred memory does not. Inflating the memory to 100,000 rules keeps retrieval under 0.8 ms, and the 1.59 s miss cycle, dominated by the LLM call, runs off the control path behind a 2.6 ms verified fallback.

Limitations

Abstraction gap and action interface. The evaluation sits at the tactical decision layer: perception is assumed as clean factored variables, highD and rounD run in replay (reactive-replay variant in Appendix § 12.§ 6), and occlusion, tracking, and map errors are absent; the five meta-actions are the standard interface of this layer and of all eight baselines, and continuous maneuvers would change only the scorer’s output head. The claims are harness results at this layer, not a deployable AV stack, and the episode-level collision rates of 5.7–9.5% in deliberately stressed traffic are not deployment grade; the supported claim is relative (49–56% below the best learned baseline). Correlational dynamics. The learned dynamics are prior-constrained but not causally identified; verification is conservative, so misattribution degrades toward rejecting actions rather than accepting unsafe ones, yet its quality depends on dynamics fidelity (constant-velocity propagation raises CR by 48–49%; 3 of the 57 acquired rules were over-specific in audit, Appendix § 12.§ 5). Limited zero-shot cross-domain reusability. Zero-shot cross-domain reusability of the compiled memory is limited: a memory compiled solely from highD/rounD begins at an 86.2% call rate on highway-env, indicating that many target-domain encounters still require online acquisition. REINS is accordingly scoped to the self-evolution loop rather than assuming universal cross-domain memory transfer (Appendix § 12.§ 7). Scope. The monotone miss-rate property assumes a stationary scene distribution, and the implementation is specialized to driving: only the variable schema and the action space must be re-authored for another domain (Appendix § 12.§ 1).

Conclusion

We present REINS, a self-evolving agent harness that adapts the agent-harness paradigm from software engineering to real-time, safety-critical trajectory planning through three LLM–planner couplings: grounding, verification, and consolidation. Familiar scenes resolve from an indexed rule memory in O(log⁡∣R∣)\mathcal{O}(\log\lvert\mathcal{R} \rvert) time, while memory misses trigger LLM-driven rule acquisition that grounds, verifies, and writes back new rules, closing the self-evolution loop without any LLM weight update. At the tactical decision layer, REINS attains 98%+ compliance, nearly 50% collision reduction, and 1.9–4.6 ms latency, with gains that survive matched baselines, observation noise, reactive replay, and cross-domain memory transfer. Future work will couple the harness to perception uncertainty and continuous maneuvers, extend it to multi-agent coordination, and move the learned dynamics toward interventional identification with incremental updates.

Acknowledgments and Disclosure of Funding

This work was supported by the European Union’s Horizon Europe research and innovation programme under Marie Skłodowska-Curie grant agreement No. 101126636 (DSTrain) and by the Technical Faculty of IT and Design at Aalborg University. This work was partly supported by the European Union under Grant 101123471 (EDGE-Skills project funded under the Digital Europe Programme). Views and opinions expressed are however those of the author(s) only and do not necessarily reflect those of the European Union or the European Commission. Neither the European Union nor the granting authority can be held responsible for them. The authors declare no competing interests.

More Details about REINS

Variable Definitions

We define macro and micro variables shown in Table 4. The macro variables represent high-level semantic categories, while micro variables are the specific measurable quantities used in the world dynamics model and rule system.

Macro VariableMicro VariableDescription
Environmentweather_typeWeather condition (clear/rain/fog/snow)
visibility_distanceVisibility range (m)
road_frictionRoad surface friction coefficient
road_typeScenario type (highway/merge/intersection/roundabout)
time_of_dayTime period (day/night/dawn/dusk)
speed_limitPosted speed limit (km/h)
Trafficheadway_distanceDistance to lead vehicle (m)
lead_speedLead vehicle speed (m/s)
lead_rel_speedRelative speed to lead vehicle (m/s)
lead_ttcTime-to-collision with lead vehicle (s)
lead_thwTime headway to lead vehicle (s)
rear_distanceDistance to rear vehicle (m)
rear_speedRear vehicle speed (m/s)
rear_rel_speedRelative speed to rear vehicle (m/s)
rear_ttcTime-to-collision with rear vehicle (s)
left_front_distanceDistance to left-front vehicle (m)
left_front_speedLeft-front vehicle speed (m/s)
left_rear_distanceDistance to left-rear vehicle (m)
left_rear_speedLeft-rear vehicle speed (m/s)
right_front_distanceDistance to right-front vehicle (m)
right_front_speedRight-front vehicle speed (m/s)
right_rear_distanceDistance to right-rear vehicle (m)
right_rear_speedRight-rear vehicle speed (m/s)
lane_density_leftLeft lane density (vehicles/100m)
lane_density_rightRight lane density (vehicles/100m)
available_gap_leftAvailable gap in left lane (m)
available_gap_rightAvailable gap in right lane (m)
cutin_riskCut-in risk indicator (0–1)
Egoego_xEgo vehicle longitudinal position (m)
ego_yEgo vehicle lateral position (m)
ego_vxEgo vehicle longitudinal velocity (m/s)
ego_vyEgo vehicle lateral velocity (m/s)
ego_speedEgo vehicle total speed (m/s)
ego_accelerationEgo vehicle acceleration (m/s²)
yaw_rateEgo vehicle yaw rate (rad/s)
jerkEgo vehicle jerk (m/s³)
lane_idCurrent lane identifier
lateral_offsetLateral offset from lane center (m)
Actionaction_typeDiscrete action (IDLE/FASTER/SLOWER/LANE_LEFT/LANE_RIGHT)
Outcomerisk_scoreCollision probability (0–1)
comfort_scoreComfort metric (jerk-based)
energy_consumptionEnergy usage metric
success_flagGoal completion indicator (boolean)
violation_flagRule violation indicator (boolean)

Table 4. Macro and micro variable definitions used in REINS.

The variables are organized into five functional groups: Environment variables capture external conditions (weather, visibility, road surface, speed limits) that affect driving but are not directly controllable. Traffic variables describe spatial and temporal relationships with surrounding vehicles, including headway distances, relative speeds, TTC, and lane density metrics. Ego variables represent the controlled vehicle’s kinematic state (position, velocity, acceleration, orientation). Action defines the discrete action space: five high-level maneuvers executed by low-level controllers. Outcome variables measure action consequences, including safety (collision risk), comfort (jerk-based), and task completion indicators. This hierarchical organization enables structured rule retrieval via variable-group indexing.

The macro-group dependency set EH\mathcal{E}_{H} in Def. 3.1 encodes the admissible group-level edges:

EH={(ENV,TRAFFIC),(ENV,EGO),(ENV,OUTCOME),(TRAFFIC,TRAFFIC),(TRAFFIC,EGO),(TRAFFIC,OUTCOME),(EGO,TRAFFIC),(EGO,EGO),(EGO,OUTCOME),(ACTION,EGO),(ACTION,OUTCOME)}.(10)\mathcal{E}_{H} = \{(\mathrm{ENV}, \mathrm{TRAFFIC}), (\mathrm{ENV}, \mathrm{EGO}), (\mathrm{ENV}, \mathrm{OUTCOME}), \\ (\mathrm{TRAFFIC}, \mathrm{TRAFFIC}), (\mathrm{TRAFFIC}, \mathrm{EGO}), (\mathrm{TRAFFIC}, \mathrm{OUTCOME}), \\ (\mathrm{EGO}, \mathrm{TRAFFIC}), (\mathrm{EGO}, \mathrm{EGO}), (\mathrm{EGO}, \mathrm{OUTCOME}), \\ (\mathrm{ACTION}, \mathrm{EGO}), (\mathrm{ACTION}, \mathrm{OUTCOME})\}. \tag*{(10)}

Environment factors influence Traffic, Ego, and Outcome; Traffic and Ego variables interact bidirectionally and feed into Outcome; Action affects only Ego state and Outcome.

Rule Templates

Seven rule templates are defined to capture different logical structures for driving knowledge:

  • IF-THEN: Conditional implication for basic conditional relations. Example: IF TTC<2s\mathrm{TTC} < 2\mathrm{s} THEN decelerate\mathrm{decelerate}

  • AND-THEN: Conjunctive trigger requiring multiple conditions. Example: IF visibility<50m\mathrm{visibility} < 50\mathrm{m} AND raining\mathrm{raining} THEN reduce_speed_by_30%\mathrm{reduce\_speed\_by\_30\%}

  • THRESHOLD: Numeric constraint with calibrated boundaries. Example: IF speed>speed_limit\mathrm{speed} > \mathrm{speed\_limit} THEN violation=true\mathrm{violation} = \mathrm{true}

  • PRIORITY: Decision hierarchy for conflicting actions. Example: yield≻accelerate\mathrm{yield} \succ\mathrm{accelerate} (yield takes priority)

  • MULTI-ACTION: Compound actions under one condition. Example: IF collision_risk=high\mathrm{collision\_risk} = \mathrm{high} THEN brake\mathrm{brake} AND steer_away\mathrm{steer\_away}

  • WEIGHTED-ACTION: Weighted action selection. Example: IF crash_risk\mathrm{crash\_risk} THEN {brake:0.7,steer:0.3}\{\mathrm{brake}: 0.7, \mathrm{steer}: 0.3\}

  • TEMPORAL-CHAIN: Temporal constraints between triggers. Example: IF obstacle_detected\mathrm{obstacle\_detected} THEN brake\mathrm{brake} within 1.5s1.5\mathrm{s}

Rule Conflict Resolution

When multiple rules are activated simultaneously, conflicts may arise if they recommend different actions. REINS resolves conflicts through a three-level arbitration mechanism:

Priority-based ordering. Rules are assigned priority levels based on their functional category: Safety >> Compliance >> Navigation >> Efficiency. When rules from different categories conflict, the higher-priority rule takes precedence. For example, if an Efficiency rule (consider lane change) and a Safety rule (maintain gap) both fire, the Safety rule overrides.

Confidence-weighted aggregation. For rules within the same priority level, REINS aggregates their scores using the noisy-OR formula (Eq. (5)). This allows multiple supporting rules to reinforce an action while remaining robust to individual noisy predictions. The action with the highest aggregated probability is selected.

Dynamics-based verification. When the aggregated action prior is below a confidence threshold (τ=0.7\tau= 0.7), REINS falls back to dynamics-based verification. The top-MM candidate actions are simulated via forward rollout using the world dynamics model, and the action yielding the safest predicted trajectory is selected.

This hierarchical approach ensures that safety-critical rules are never overridden by efficiency considerations, while still allowing flexible action selection in non-critical situations.

Method Details

This subsection contains the full equations, architectural details, and explanatory prose deferred from the methodology to keep the main body concise. The structure mirrors § 4.1–§ 4.2.

World Dynamics Learning Details

We learn the dependency graph G^=(X,E^,w^)\widehat{G} = (\mathcal{X}, \widehat{\mathcal{E}}, \widehat{w}) in three steps, then train a per-variable dynamics function on the resulting parent sets.

Step 1: Edge Prior Estimation. We query the LLM with variable dependency prompts (Appendix A.5) to obtain an edge confidence πij∈[0,1]\pi_{ij} \in[0, 1] for each candidate edge Xj→XiX_j \to X_i. This is combined with the macro-group constraints (Eq. (10)) to form a unified prior:

π~ij=απij+(1−α)I{(h(Xj),h(Xi))∈EH},(11)\widetilde{\pi}_{ij} = \alpha\pi_{ij} + (1-\alpha)\mathbb{I}\{(h(X_j), h(X_i)) \in\mathcal{E}_{\mathcal{H}}\}, \tag*{(11)}

where α∈[0,1]\alpha\in[0, 1] balances LLM confidence against structural constraints. Edges that violate the macro-group constraints carry indicator 0 and are reduced to απij\alpha\pi_{ij}, while semantically aligned edges are pushed toward 1.

Step 2: Prior-Guided Regression. For each target variable XiX_i, we predict its value from the lagged values of other variables via ridge regression [13] with prior-adaptive penalties λij=λ0(1−π~ij)ρ\lambda_{ij} = \lambda_0(1-\widetilde{\pi}_{ij})^\rho:

w^i=arg min⁡wi ∑t=LN(Xit−∑j≠i∑ℓ=1LwjℓXjt−ℓ)2+∑j≠iλij∥wj∥22,(12)\widehat{\mathbf{w}}_i = \underset{\mathbf{w}_i}{\operatorname{arg\,min}}\ \sum_{t=L}^{N}\left(X_i^t-\sum_{j\ne i}\sum_{\ell=1}^{L}w_{j\ell}X_j^{t-\ell}\right)^2+\sum_{j\ne i}\lambda_{ij}\lVert\mathbf{w}_j\rVert_2^2, \tag*{(12)}

where wjℓw_{j\ell} is the regression coefficient for variable XjX_j at lag ℓ∈{1,…,L}\ell\in\{1,\ldots,L\}, wj=(wj1,…,wjL)T\mathbf{w}_j = (w_{j1},\ldots,w_{jL})^{\mathsf{T}} groups all lags for XjX_j, λ0\lambda_0 is the base penalty, and ρ>0\rho> 0 controls penalty sharpness. High-prior edges (π~ij→1\widetilde{\pi}_{ij} \to1) receive weak regularization and survive; low-prior edges are shrunk toward zero.

Step 3: Graph Construction. The parent set Pa⁡(Xi)\operatorname{Pa}(X_i) retains the top-KK variables ranked by aggregated coefficient magnitude ∑ℓ=1L∣w^jℓ∣\sum_{\ell=1}^{L}|\widehat{w}_{j\ell}|. The learned edge set and weights are

E^={(Xj,Xi)∣Xj∈Pa⁡(Xi)},w^(Xj,Xi)=∑ℓ=1L∣w^jℓ∣.(13)\widehat{\mathcal{E}} = \{(X_j,X_i)\mid X_j \in\operatorname{Pa}(X_i)\},\qquad\widehat{w}(X_j,X_i)=\sum_{\ell=1}^{L}|\widehat{w}_{j\ell}|. \tag*{(13)}

Dynamics Function Loss. Given G^\widehat{G}, each fif_i is implemented as a multi-head Transformer [39] and trained by mean squared error over its parent trajectory:

Ldyn(i)=1N∑t(Xit+1−fi(Pa⁡(Xi)t−L+1:t))2.(14)\mathcal{L}_{\mathrm{dyn}}^{(i)}=\frac{1}{N}\sum_t\left(X_i^{t+1}-f_i\left(\operatorname{Pa}(X_i)_{t-L+1:t}\right)\right)^2. \tag*{(14)}

Optimizer, batch size, and convergence curves are reported in Appendix C.1.

Rule Compilation Details

Rule Structure Generation. For each dependency edge (Xj,Xi)∈E^(X_j,X_i) \in\widehat{\mathcal{E}}, the LLM generates a rule structure

r=(T,Pr,ar,cr),(15)r=(T,\mathcal{P}_r,a_r,c_r), \tag*{(15)}

where TT is the rule template (Def. 3.5), Pr\mathcal{P}_r is a set of guard predicates with symbolic thresholds, ar∈Aa_r \in\mathcal{A} is the recommended action (Def. 3.2), and crc_r is the confidence derived from edge weight w^(Xj,Xi)\widehat{w}(X_j,X_i). Prompt details are in Appendix A.5.

Threshold Calibration. Each predicate p∈Prp \in\mathcal{P}_r (Def. 3.4) requires a concrete threshold τi\tau_i, calibrated from DD in three forms [25]:

τi={μi+ζσi(z-score),Qi(ζ)(quantile),τ0(absolute),(16)\tau_i = \begin{cases} \mu_i + \zeta\sigma_i & \text{(z-score)},\\ Q_i(\zeta) & \text{(quantile)},\\ \tau_0 & \text{(absolute)}, \end{cases} \tag*{(16)}

where μi\mu_i, σi\sigma_i are empirical mean and standard deviation of XiX_i, Qi(ζ)Q_i(\zeta) is the ζ\zeta-quantile, and τ0\tau_0 is a fixed constant (e.g., speed limits). The comparison operator ≺\prec is selected to maximize safety separability between the two sides of the threshold under safety outcome y∈{0,1}y \in\{0,1\} (§ 4.1.2).

Graph Database Storage. Compiled rules are stored in a Neo4j graph database [42] with a variable-indexed schema (Figure 3). Each rule node stores the complete tuple (T,Pr,ar,cr)(T,\mathcal{P}_r,a_r,c_r), where TT is the template type, Pr\mathcal{P}_r contains calibrated predicates with concrete thresholds τ\tau and operators ≺\prec, ara_r is the recommended action, and crc_r is the confidence. Rule nodes connect to variable nodes via TRIGGERS (input variables) and AFFECTS (output variables) edges. This enables O(log⁡∣R∣)O(\log|\mathcal{R}|) retrieval via parameterized Cypher queries on variables active in the current state. Database statistics are provided in Appendix § 11.7.1.

Rule-Guided Planning Details

Scene-Aware Rule Retrieval. Given st∈Ss_t \in\mathcal{S}, we identify active variables {Xi}\{X_i\} and retrieve context-relevant rules via parameterized Cypher queries [8] generated by the LLM (read-only and schema-constrained; Appendix § 9.§ 5). The retrieval map

G:({Xi},K)⟼Rt⊆R(17)G : (\{X_i\}, K) \longmapsto\mathcal{R}_t \subseteq\mathcal{R} \tag*{(17)}

returns up to KK rules ranked by confidence crc_r. A rule rr is retrieved if its trigger variables {Xj∣(Xj,r)∈TRIGGERS}\{X_j \mid(X_j,r) \in\mathrm{TRIGGERS}\} intersect with the active set {Xi}\{X_i\} and the dependency direction satisfies the macro-group constraints EH\mathcal{E}_{\mathcal{H}}.

Action Scorer Architecture. The Transformer scorer [22] takes state encoding xtx_t and rule embedding uru_r and emits relevance and action heads:

ht,r=TransformerEnc⁡([xt;ur]),Srel(r,st)=σ(Dec⁡rel(ht,r))∈[0,1],Sact(r,st,a)=softmax⁡(Dec⁡act(ht,r))a,(18)\begin{aligned} h_{t,r} &= \operatorname{TransformerEnc}([x_t;u_r]),\\ S_{\mathrm{rel}}(r,s_t) &= \sigma(\operatorname{Dec}_{\mathrm{rel}}(h_{t,r})) \in[0,1],\\ S_{\mathrm{act}}(r,s_t,a) &= \operatorname{softmax}(\operatorname{Dec}_{\mathrm{act}}(h_{t,r}))_a, \tag*{(18)} \end{aligned}

where SrelS_{\mathrm{rel}} predicts whether rr should influence the current decision, and SactS_{\mathrm{act}} predicts the action preference given rr. The combined rule-action score multiplies relevance, action preference, and rule confidence:

f(r,a∣st)=Srel(r,st)⋅Sact(r,st,a)⋅cr.(19)f(r,a \mid s_t) = S_{\mathrm{rel}}(r,s_t) \cdot S_{\mathrm{act}}(r,s_t,a) \cdot c_r. \tag*{(19)}

Scorer Training. The scorer is trained on expert trajectories {(st,at∗)}\{(s_t,a_t^*)\} with a joint relevance + action objective:

L=∑t,r[BCE⁡(Exec⁡(r,st),Srel(r,st))−log⁡Sact(r,st,at∗)].(20)\mathcal{L} = \sum_{t,r} \left[\operatorname{BCE}(\operatorname{Exec}(r,s_t),S_{\mathrm{rel}}(r,s_t))-\log S_{\mathrm{act}}(r,s_t,a_t^*)\right]. \tag*{(20)}

where Exec⁡(r,st)∈{0,1}\operatorname{Exec}(r,s_t) \in\{0,1\} is the ground-truth rule activation (Eq. (2)) and at∗a_t^* is the expert action.

Action Aggregation. The full noisy-OR action distribution corresponding to Eq. (5) is

P(a∣st)=1−∏r∈Rt(a)(1−f(r,a∣st))Z,P(a \mid s_t) = \frac{1-\prod_{r\in\mathcal{R}_t(a)}(1-f(r,a\mid s_t))}{Z},
arule∗=arg⁡max⁡a∈A P(a∣st).(21)a_{\mathrm{rule}}^* = \underset{a\in A}{\arg\max}\ P(a\mid s_t). \tag*{(21)}

where Rt(a)⊆Rt\mathcal{R}_t(a) \subseteq\mathcal{R}_t denotes the rules with recommended action ar=aa_r = a and ZZ normalizes over A\mathcal{A}. The formulation favors actions supported by multiple high-confidence rules.

Trajectory Verification. For the top-MM actions ranked by P(a∣st)P(a \mid s_t), we predict HH-step future states:

s^t+h+1=Φ(s^t+h,a;G^,F^),h=0,…,H−1,(22)\hat{s}_{t+h+1} = \Phi(\hat{s}_{t+h}, a; \hat{G}, \hat{F}), \qquad h = 0,\ldots,H-1, \tag*{(22)}

where Φ\Phi applies each fi∈F^f_i \in\hat{F} to predict XiX_i from Pa⁡(Xi)\operatorname{Pa}(X_i) under G^\hat{G}. Each rollout produces a candidate trajectory ξ^(a)=(s^t+1,…,s^t+H)\hat{\xi}(a) = (\hat{s}_{t+1},\ldots,\hat{s}_{t+H}), consistent with Def. 3.3. The planner selects at∗=arg⁡max⁡a∈AMJ(ξ^(a))a_t^* = \arg\max_{a \in A_M} J(\hat{\xi}(a)), where J:SH→RJ : \mathcal{S}^{H} \to\mathbb{R} penalizes collisions, rule violations, and control effort (Appendix § 10.§ 2); the first control of the selected trajectory is executed in receding-horizon [46].

Online Rule Acquisition Details

LLM-Driven Rule Proposal. On a miss, the harness queries M\mathcal{M} with the current state and active variables:

r~=(T~,P~,a~,c~)∼M(st),(23)\tilde{r} = (\tilde{T}, \tilde{P}, \tilde{a}, \tilde{c}) \sim\mathcal{M}(s_t), \tag*{(23)}

where r~\tilde{r} conforms to the rule template (Def. 3.5) and uses only variables in X\mathcal{X} and operators from the predicate grammar (Def. 3.4). Prompt details are in Appendix § 9.§ 5.

Safe-Action Selection. When online rule acquisition rejects r~\tilde{r} and Rt=∅\mathcal{R}_t = \varnothing, the harness raises a human-takeover alert and executes the action that maximizes minimum lookahead time-to-collision under F^\hat{F}:

atsafe=arg⁡max⁡a∈Amin⁡h∈[1,H]TTC⁡(s^t+h(a)).(24)a_t^{\mathrm{safe}} = \arg\max_{a \in\mathcal{A}} \min_{h \in[1,H]} \operatorname{TTC}(\hat{s}_{t+h}(a)). \tag*{(24)}

Memory-Update Collision Branch. Eq. (8)’s collision branch averages confidences instead of creating a duplicate node, so ∣R∣|\mathcal{R}| counts distinct rule structures rather than LLM-noise replicas. The hash κ\kappa is computed over the structural triple (T~,P~,a~)(\tilde{T}, \tilde{P}, \tilde{a}) but excludes c~\tilde{c}, so semantically identical proposals collide regardless of confidence noise. Collisions are common during early deployment when R\mathcal{R} is small, then taper off as coverage saturates.

Self-Evolution Properties. Eq. (8) structurally enforces ∣Rt+1∣≥∣Rt∣|\mathcal{R}_{t+1}| \geq|\mathcal{R}_t| (memory monotonicity) and θM≡θM(0)\theta_{\mathcal{M}} \equiv\theta_{\mathcal{M}}^{(0)} (no LLM parameter update). Under stationarity of the scene distribution, the per-state miss rate is non-increasing as R\mathcal{R} accumulates coverage, since any state ss that triggered a miss and produced an accepted r~\tilde{r} is now matched by a rule keyed on the variables active at ss. Since M\mathcal{M} is invoked only on misses, its per-scene invocation rate decays monotonically with Pr⁡[Miss]\Pr[\mathrm{Miss}]. We validate this behavior empirically in § 5.4 and Appendix § 11.§ 5.

Prompts

We provide three prompt templates used in REINS’s offline compilation pipeline. Figure 4 shows the Variable Dependency Prompt, which instructs the LLM to infer dependencies between driving variables based on domain knowledge; the output serves as semantic priors for structure learning in the world dynamics model. Figure 5 presents the Rule Extraction Prompt, which converts dependency edges into executable driving rules with parameterized guards and discrete actions; these rules are stored in the Neo4j graph database. Figure 6 displays the Parameterized Cypher Query Prompt, which generates parameterized queries for context-aware rule retrieval during planning. All prompts enforce read-only constraints and structured output formats to ensure safety and parseability.

Variable Dependency Prompt

Figure 4. Variable dependency prompt. Given a list of driving-related variables, the LLM infers directed dependency relationships as structural priors for the world dynamics model.

Rule Extraction Prompt

Figure 5. Rule extraction prompt from dependency structure.

Parameterized Cypher query prompt
Parameterized Cypher Query Prompt

[TASK]
You are an expert in Neo4j graph databases and autonomous driving systems.
Generate a parameterized, read-only Cypher query to retrieve relevant driving rules based on the current scene context.

[INPUT]
You are given the following information about the current driving scene:
• Scene summary: {scene_summary}
• Active cause variables: {active_causes}
• Target variable groups: {target_groups} (e.g., Outcome, Ego, Action)
• Maximum results: {k}

[GRAPH SCHEMA]
The rule database contains the following structure:
• Nodes: (Rule), (Variable), (Category), (Group), (Action)
• Relations: [:TRIGGERS], [:CAUSES], [:BELONG_TO]

[CONSTRAINTS]
Your query must satisfy the following safety requirements:
• Query MUST start with: MATCH, WITH, RETURN, CALL, or UNWIND
• NO write operations: CREATE, MERGE, SET, DELETE, DETACH, LOAD, DROP, ALTER
• Use parameter placeholders: $active_causes, $target_groups, $k

[OUTPUT]
Return only the Cypher query string enclosed in triple quotes. Do not include any explanations.

"""
<Cypher query here>
"""

[EXAMPLE]

"""
MATCH (r:Rule)-[:TRIGGERS]->(c:Variable)-[:CAUSES*0..1]->(e:Variable)
WHERE c.name IN $active_causes AND e.group IN $target_groups
RETURN r.rule_id, r.text, collect(e.name) AS effects,
       r.type, r.confidence
ORDER BY r.confidence DESC LIMIT $k
"""

Ensure the query is syntactically correct and adheres to all constraints.

Figure 6. Parameterized Cypher query prompt.

Implementation Details

Experiment Settings

Table 5 summarizes the key hyperparameters and training configurations used in our experiments. The settings are organized into six categories: Simulation Environment specifies the highway-env simulator settings, including four driving scenarios with varying complexity and a discrete action space of five high-level maneuvers. Real-world Datasets describes the highD (highway) and rounD (roundabout) drone datasets used for real-world evaluation, including recording statistics.

CategorySetting
Simulation Environment
Simulatorhighway-env v1.8.2
ScenariosHighway, Merge, Roundabout, Intersection
Episode length100 steps (20s at 5 Hz)
Observation15 nearest vehicles
Action space{IDLE, FASTER, SLOWER, LANE_LEFT, LANE_RIGHT}
Weather conditionsClear, Rain, Fog, Snow
Real-world Datasets
highD sourceGerman Autobahn (drone)
highD recordings01, 02, 03, 04
highD vehicles4,237 (578 lane-change events)
rounD sourceGerman roundabouts
rounD recordings00, 01, 02
rounD vehicles2,156 (423 yield/merge events)
Sampling rate25 Hz
World Dynamics Model
Structure learningRidge regression + LLM prior
LLM prior weight α\alpha0.6
Penalty exponent ρ\rho2.0
Base regularization λ0\lambda_00.1
Lag length LL6 steps
Top-KK parents5
Transformer layers2
Attention heads4
OptimizerAdam
Learning rate2×10−42 \times10^{-4}
Batch size64
Training episodes50k
Rule Compilation (Offline)
LLM backboneGPT-4o (2024-08-06)
LLM temperature0.0 (deterministic)
Max output tokens4096
Prompt tokens (avg.)∼\sim1.2k per query
Total LLM calls∼\sim50 (one-time offline)
Rule templates7 types
Neo4j version5.12
Threshold calibrationGaussian (μ+ζσ\mu+ \zeta\sigma), ζ\zeta=1.5
Confidence τ\tau0.7
Training & Evaluation
Training data50k episodes
Test episodes1000 per scenario
Random seeds5 (0, 42, 123, 456, 789)
Training hardware4×\times A100 (40GB)
Training time∼\sim8 hours
Planning & Deployment
Retrieval count kk10
Planning horizon HH5 steps
Rollout discount γ\gamma0.99
Safety weight λsafe\lambda_{\mathrm{safe}}1.0
Comfort weight λcomf\lambda_{\mathrm{comf}}0.1
Progress weight λprog\lambda_{\mathrm{prog}}0.5
Inference hardwareRTX 3090 or above
GPU memory∼\sim4 GB
Neo4j query latency<1<1 ms
Planning latency1.9–4.6 ms per decision
Real-time capability200–500 Hz

Table 5. Experiment settings and hyperparameters for REINS.

and sampling rates. World Dynamics Model details the structure learning parameters (LLM prior weight, regularization) and neural network architecture (Transformer layers, attention heads). Rule Compilation covers the offline LLM-based rule generation process, including the backbone model, sampling strategy, and threshold calibration. Training & Evaluation specifies the data splits, random seeds, and hardware configuration. Planning & Deployment reports inference-time parameters and latency measurements demonstrating real-time capability. All hyperparameter configurations follow standard practices unless otherwise stated.

Evaluation Metrics

Rule Compliance (Compl.) measures the fraction of timesteps where all active rules are satisfied:

Compl.=1T∑t=1T∏k=1K(1−vk,t),(25)\mathrm{Compl.} = \frac{1}{T}\sum_{t=1}^{T}\prod_{k=1}^{K}(1-v_{k,t}), \tag*{(25)}

where vk,t∈{0,1}v_{k,t} \in\{0,1\} indicates whether rule kk is violated at time tt.

Collision Rate (CR) measures the fraction of episodes in which at least one collision occurs:

CR=1N∑i=1NI(collision in episode i),(26)\mathrm{CR} = \frac{1}{N}\sum_{i=1}^{N}\mathbb{I}(\text{collision in episode }i), \tag*{(26)}

where NN is the number of test episodes. A lower CR indicates safer planning.

Risk-aware Efficiency (RE) balances task performance against safety:

RE=Rtask(τ)−λriskRrisk(τ),(27)\mathrm{RE} = R_{\mathrm{task}}(\tau) - \lambda_{\mathrm{risk}}R_{\mathrm{risk}}(\tau), \tag*{(27)}
Rrisk(τ)=∑t=1Tmax⁡(0,δttc−TTCt),(28)R_{\mathrm{risk}}(\tau) = \sum_{t=1}^{T} \max(0, \delta_{\mathrm{ttc}} - \mathrm{TTC}_t), \tag*{(28)}

where RtaskR_{\mathrm{task}} is the task reward, RriskR_{\mathrm{risk}} penalizes low TTC states, λrisk=0.5\lambda_{\mathrm{risk}} = 0.5 is the risk penalty weight, and δttc=3.0s\delta_{\mathrm{ttc}} = 3.0\mathrm{s} is the TTC threshold.

Planning Efficiency (PE) measures average computation time per decision:

PE=1T∑t=1Ttplan,(29)\mathrm{PE} = \frac{1}{T}\sum_{t=1}^{T} t_{\mathrm{plan}}, \tag*{(29)}

where tplant_{\mathrm{plan}} (ms) is the wall-clock time for action selection.

Trajectory Objective J(ξ^)J(\hat{\xi}). The trajectory-level objective used in dynamics-based verification is defined as:

J(ξ^)=∑h=1Hγh−1[−λsafe⋅I(TTCt+h<τttc)+λprog⋅Δdt+h−λcomf⋅∣jt+h∣],(30)J(\hat{\xi}) = \sum_{h=1}^{H} \gamma^{h-1}\left[-\lambda_{\mathrm{safe}}\cdot\mathbb{I}(\mathrm{TTC}_{t+h}<\tau_{\mathrm{ttc}}) + \lambda_{\mathrm{prog}}\cdot\Delta d_{t+h} - \lambda_{\mathrm{comf}}\cdot\lvert j_{t+h}\rvert\right], \tag*{(30)}

where TTCt+h\mathrm{TTC}_{t+h} is the predicted time-to-collision, Δdt+h\Delta d_{t+h} is the progress toward the goal, jt+hj_{t+h} is the jerk, and τttc=2.0 s\tau_{\mathrm{ttc}}=2.0\,\mathrm{s} is the safety threshold. The weights λsafe=1.0\lambda_{\mathrm{safe}}=1.0, λprog=0.5\lambda_{\mathrm{prog}}=0.5, λcomf=0.1\lambda_{\mathrm{comf}}=0.1 prioritize safety over progress and comfort.

Real-world Evaluation Protocol. We use closed-loop replay: one recorded vehicle is controlled by the planner while others follow recorded trajectories. Collisions are detected when bounding boxes overlap or the ego deviates beyond lane boundaries. In the simulated scenarios the surrounding vehicles instead react to the ego (IDM with MOBIL); a reactive-replay variant of highD is reported in Appendix § 12.§ 6.

Baseline Descriptions

We select baselines from three categories to comprehensively evaluate REINS: (i) classical planners (MPC, MCTS) that represent traditional optimization and search-based approaches without rule guidance; (ii) LLM-based planners (DriveSpeak, PDDL, LLaDA, DriReg) that leverage language models for driving decisions but differ in how they integrate linguistic knowledge; and (iii) hybrid methods (SymAgent, Plan-R1) that combine learning with symbolic reasoning. This selection covers the spectrum from rule-free to rule-guided planning, enabling analysis of how different rule representation and retrieval strategies affect safety and efficiency.

  • MPC [7]: Classical optimization-based planner solving finite-horizon control under kinematic and safety constraints. We use a 5-step horizon with quadratic cost on acceleration and jerk.

  • MCTS [18]: Sampling-based planning via tree search and rollout evaluation. We use 1000 simulations per decision with UCB exploration.

  • DriveSpeak [5]: LLM-based method mapping natural-language scene descriptions directly to driving actions. Uses GPT-4o with scene prompts at each timestep.

  • PDDL [12, 24]: the LLM writes the domain’s symbolic preconditions and effects once offline; at runtime a classical STRIPS solver (Pyperplan [1]) is invoked in process at each decision step with no LLM call. Its runtime profile is in Appendix § 12.§ 3.

  • LLaDA [20]: LLM interpretation of region-specific traffic rules from driver handbooks. Uses pre-extracted rule sets with LLM-based rule matching.

  • DriReg [3]: RAG-based traffic regulation retrieval with LLM reasoning for action legality. Retrieves top-5 regulations per query using embedding similarity.

  • SymAgent [23]: Neural-symbolic agent integrating LLMs with structured knowledge graphs. Uses the same Neo4j backend as REINS for fair comparison.

  • Plan-R1 [37]: Two-stage learning-based planner with rule-shaped rewards and reinforcement learning. Trained on the same 50k episodes as REINS’s world model.

All baselines use identical observation spaces, action spaces, episodes, and evaluation protocols. For LLM-based methods, we use GPT-4o (2024-08-06) with temperature 0 for deterministic outputs. Hyperparameters for each baseline follow their original papers or are tuned on a held-out validation set. The conditions that are shared with REINS and those that each rule-based baseline keeps by design, together with a matched re-run and a common-reference compliance audit, are documented in Appendix § 12.§ 2.

Additional Results

Training Convergence

We train the world dynamics model for 300 epochs using the Adam optimizer with a learning rate of 2×10−42 \times10^{-4} and batch size 64. Each variable-specific dynamics function fif_i is implemented as a two-layer Transformer with four attention heads. Training is conducted on 50k episodes collected from four scenarios (Highway, Intersection, Merge, and Roundabout) using NVIDIA A100 GPUs. The model learns 20 variable-specific dynamics functions, including ego-state variables (ego_speed, ego_acceleration, ego_vx, ego_vy, ego_x, ego_y, yaw_rate, jerk, lane_id), traffic-related variables (lead_ttc, lead_thw, lead_rel_speed, rear_rel_speed, lane_density_left, lane_density_right, cutin_risk), and outcome variables (risk_score, comfort_score, violation_flag, energy_consumption). Figure 7 shows the training loss curves for all dynamics functions across the four scenarios.

Figure 7. Training loss convergence for the World Dynamics Learning. Each subplot shows one variable’s dynamics learning across four scenarios (Highway, Intersection, Merge, Roundabout). All variables converge within 150 epochs, with scenario-dependent convergence rates reflecting inherent complexity differences.

The results suggest that the learned world dynamics are scenario-adaptive not only in difficulty but also in structural composition: different scenarios activate and learn different subsets of variable-specific dynamics functions. Interaction-heavy variables such as cutin_risk, lane_density_left/right, and rear_rel_speed are prominent in Merge and Intersection, where lane changes and merging behaviors are frequent, but are weakly activated or effectively absent in Highway, where traffic flow is comparatively stable. Conversely, lateral-motion variables (e.g., ego_vy, yaw_rate) become substantially more relevant in Roundabout due to persistent curvature, while contributing marginally in straight-road scenarios. This indicates that the model does not impose a fixed global mechanism set across environments, but instead learns scenario-specific mechanism structures, supporting structural adaptability to heterogeneous traffic contexts.

Beyond these structural differences, the loss curves exhibit consistent convergence patterns. Most variables converge within 100–150 epochs. Simple kinematic variables (e.g., ego_x, ego_y, lead_thw) converge within 50 epochs, whereas interaction-intensive outcome variables (e.g., risk_score, violation_flag) require longer training. Highway achieves the lowest final loss due to simpler lane-following dynamics. Roundabout exhibits higher loss for lateral variables because of curved trajectories, while Intersection shows higher variance in violation_flag due to diverse right-of-way interactions. Safety-related variables (e.g., lead_ttc, cutin_risk) converge rapidly in early training when relevant interactions are present, indicating strong dependency signals. In terms of final loss magnitude, continuous variables (e.g., ego_speed, ego_acceleration) achieve losses below 0.5, whereas discrete or binary variables (e.g., violation_flag, lane_id) stabilize at higher loss due to their classification nature.

Trajectory Accuracy

We evaluate trajectory accuracy using Average Displacement Error (ADE), Final Displacement Error (FDE), and cumulative episode reward (Reward) across four driving scenarios: Highway, Merge, Roundabout, and Intersection. ADE and FDE measure the mean and final Euclidean distance between predicted and executed trajectories, respectively, while Reward reflects overall driving efficiency and safety. All methods are evaluated under identical environment settings with the same observation space, action space, and rollout horizon.

Table 6 reports the mean performance over all evaluation episodes. REINS consistently achieves the best performance across all scenarios in terms of both trajectory accuracy and cumulative reward. In Highway, REINS reduces ADE and FDE to 15.9 and 20.5, respectively, outperforming the strongest baseline (SymAgent) by 12.2% in ADE and 16.3% in FDE, while also achieving the highest reward. Similar improvements are observed in Merge and Roundabout, where REINS yields substantial gains in both short-horizon and long-horizon prediction accuracy, indicating more stable multi-step trajectory generation.

Scen.MetricLLaDAMPCSymAgentREINS
Hig.ADE↓\downarrow26.520.118.115.9
FDE↓\downarrow29.525.124.520.5
Reward↑\uparrow14.721.623.126.3
Mer.ADE↓\downarrow17.613.312.79.9
FDE↓\downarrow21.820.018.515.2
Reward↑\uparrow25.250.754.558.4
Rou.ADE↓\downarrow19.716.514.310.1
FDE↓\downarrow23.221.719.414.9
Reward↑\uparrow12.322.923.627.8
Int.ADE↓\downarrow21.69.68.05.6
FDE↓\downarrow25.413.611.29.7
Reward↑\uparrow35.354.256.860.5

Table 6. Trajectory accuracy comparison (mean values).

The performance gap becomes more pronounced in complex interaction scenarios. In Intersection, REINS achieves an ADE of 5.6 and FDE of 9.7, representing relative reductions of 30.0% and 13.4% compared to SymAgent, and 41.7% (ADE) and 28.7% (FDE) compared to MPC. This suggests that integrating rule-guided action selection with world-model-based forward rollout is particularly effective when decision-making requires anticipating multi-agent interactions and right-of-way constraints.

Across all scenarios, higher trajectory accuracy strongly correlates with higher episode reward, confirming that more accurate future state prediction leads to safer and more efficient planning. Methods relying primarily on language-based reasoning (LLaDA) exhibit the largest errors, especially in high-speed or curved-road settings, highlighting the limitations of planning without explicit dynamics modeling. MPC improves performance by incorporating learned motion predictors, while SymAgent further benefits from symbolic constraints. REINS combines symbolic rule guidance with learned world dynamics, enabling both structured action filtering and predictive verification, which explains its consistent superiority across heterogeneous traffic scenarios.

Sensitivity to Retrieval Count kk and Planning Horizon HH

We analyze sensitivity to two runtime hyperparameters: rule retrieval count kk (the maximum number of rules returned per scene by the Cypher query) and planning horizon HH (the rollout depth used by trajectory verification). Both are evaluated on simulated (Highway, Roundabout) and real-world (highD, rounD) scenarios.

Rule Retrieval Count kk. tbl:9a reports results for varying kk. Small values (k≤3k \le3) miss critical rules, increasing CR by 3.5–4.7 points; large values (k≥15k \ge15) introduce redundancy, raising PE by 60–71% at k=20k=20 without safety gains. The optimal k=10k=10 generalizes across domains, with real-world and roundabout scenarios showing higher sensitivity than structured highway settings.

Planning Horizon HH. tbl:9b reports results for varying HH. Short horizons (H≤3H \le3) cause myopic decisions with 2.9–5.1 point CR increase; long horizons raise PE by 35–44% at H=7H=7 and roughly

double it at H=10H=10, with marginal safety benefits. The optimal H=5H=5 balances safety and efficiency, though complex scenarios (Roundabout, rounD) require longer horizons to anticipate multi-agent interactions.

Sensitivity to Temporal Lag Length

The temporal lag length LL determines how many historical timesteps the world dynamics model uses when predicting future states. Table 7 reports results on both simulated and real-world scenarios.

DatasetScen.MetricL=2L=2L=4L=4L=6L=6L=8L=8L=10L=10
Sim.Hig.Compl.0.99340.99480.99560.99520.9947
RE-0.420.310.520.380.15
CR (%)9.346.895.676.727.98
PE (ms)2.212.352.502.682.89
Rou.Compl.0.98980.99150.99250.99180.9908
RE-1.23-0.78-0.54-0.72-0.95
CR (%)14.1210.789.0110.3411.89
PE (ms)3.183.413.623.894.21
RealhighDCompl.0.98450.98580.98670.98610.9852
RE-0.350.180.380.250.08
CR (%)10.127.346.127.128.56
PE (ms)2.382.522.622.873.12
rounDCompl.0.98230.98420.98560.98480.9834
RE-1.12-0.65-0.41-0.58-0.82
CR (%)15.2311.349.4510.7812.45
PE (ms)3.523.763.894.254.63

Table 7. Sensitivity to temporal lag length LL (default: 6).

When using small lag lengths (L≤2L \le2), the model fails to capture cumulative temporal patterns such as sustained tailgating or gradual lane drift, leading to substantially higher collision rates. On the simulated Highway scenario, the collision rate increases from 5.67% at L=6L=6 to 9.34%, corresponding to a 65% relative increase. A similar degradation is observed on the real-world highD dataset, where the collision rate rises from 6.12% to 10.12%. These results indicate that short-term observations are insufficient to infer latent interaction states, such as risk accumulation and driver intent, which are critical for safe planning. In contrast, large lag lengths (L≥10L \ge10) introduce excessive historical noise and dilute recent dependency signals, reducing the effective signal-to-noise ratio for short-horizon prediction. Consequently, collision rates increase by approximately 40% on simulated scenarios compared to the optimal setting. This suggests that overly long histories may impair the model’s ability to focus on immediately relevant dynamics, particularly in rapidly evolving traffic situations.

Overall, L=6L=6 achieves the best and most consistent performance across both simulated and real-world domains, corresponding to approximately 1.2 seconds of historical context at a sampling rate of 5 Hz. This time window appears sufficient to capture short-term interaction dynamics while avoiding the accumulation of outdated or irrelevant information, thereby supporting stable multi-step rollout and reliable safety verification in downstream planning.

DatasetScen.Metrick=3k=3k=5k=5k=10k=10k=15k=15k=20k=20DatasetScen.MetricH=3H=3H=5H=5H=7H=7H=10H=10
Sim.Hig.Compl.0.97120.98560.99560.99480.9951Sim.Hig.Compl.0.99480.99560.99530.9949
RE0.180.410.520.350.21RE-0.120.520.480.41
CR (%)9.217.085.676.026.48CR (%)8.565.675.915.78
PE (ms)1.822.132.503.214.15PE (ms)1.872.503.425.18
Rou.Compl.0.95890.97780.99250.99120.9908Rou.Compl.0.99080.99250.99190.9912
RE-1.12-0.78-0.54-0.72-0.89RE-1.02-0.54-0.62-0.71
CR (%)13.3410.459.019.6210.28CR (%)12.789.019.629.38
PE (ms)2.673.123.624.565.78PE (ms)2.783.624.897.34
RealhighDCompl.0.96890.97980.98670.98560.9852RealhighDCompl.0.98560.98670.98620.9854
RE0.050.250.380.220.09RE-0.080.380.340.28
CR (%)10.017.636.126.587.08CR (%)9.786.126.486.32
PE (ms)2.052.382.623.524.48PE (ms)2.122.623.765.62
rounDCompl.0.95340.97120.98560.98420.9836rounDCompl.0.98380.98560.98480.9841
RE-1.02-0.65-0.41-0.58-0.76RE-0.89-0.41-0.52-0.62
CR (%)14.1211.089.4510.0210.75CR (%)14.569.4510.069.78
PE (ms)2.983.483.895.026.28PE (ms)3.153.895.528.18

Table 9. (a) Rule retrieval count kk. (b) Planning horizon HH. Table 9: Sensitivity to retrieval count kk (left) and planning horizon HH (right).

Self-Evolution Across Scenarios

This appendix reports self-evolution dynamics on the remaining simulated scenarios (Merge, Roundabout, Intersection) and the real-world datasets (highD, rounD), complementing the Highway results in Section 5.4. For each scenario, we deploy REINS for 1000 episodes from the offline-compiled memory R0R_0 and report ∣R∣|R|, LLM call rate, Compl., and CR at four deployment checkpoints (ep. 250, 500, 750, 1000), with a Frozen R0R_0 row showing the same 1000-episode window run with acquisition disabled; this row exposes ∣R0∣|R_0| and isolates the contribution of online rule writing from any aggregation effect of running more episodes. The per-scenario ∣R∣|R| at ep. 1000 matches the post-deployment totals in Table 8.

TemplateSimulation Hig.Simulation Mer.Simulation Rou.Simulation Int.Real-world highDReal-world rounDTotal
IF-THEN424850553843276
AND-THEN384547523237251
THRESHOLD323536403032205
PRIORITY122022281521118
MULTI-ACTION10131417111277
WEIGHTED-ACTION6891171051
TEMPORAL-CHAIN567751545
Total1451751852101381701,023

Table 8. Post-deployment distribution of rules by template type across driving scenarios (after 1000-episode self-evolution per scenario).

Three patterns emerge across the five extended scenarios, mirroring the Highway dynamics. First, ∣R∣|R| exhibits saturating growth: approximately 44% of the rule additions (counted from ∣R0∣|R_0| in the Frozen row to ∣R∣|R| at ep. 1000) occur in the first 250 episodes, with diminishing returns thereafter, so the LLM is invoked predominantly for previously unseen scene clusters. Second, the LLM call rate decays monotonically in all scenarios, from 68–79% in the first 250-episode window to 12–19% by ep. 1000 (a 4.2–5.5× reduction); scene complexity raises the absolute size of RR and the residual call rate (highest on Intersection) but not the shape of the decay. Third, the Frozen R0R_0 control consistently underperforms the evolving memory at ep. 1000 (mean Compl. gap ≈0.017, mean CR gap ≈4.2 points), confirming that the gains attributable to online acquisition are not artifacts of statistical aggregation over a longer evaluation window. Intersection benefits most (Compl. +0.0218, CR −4.87 points from Frozen to ep. 1000), reflecting larger room for online acquisition where the offline R0R_0 is most incomplete relative to right-of-way reasoning; the other four scenarios cluster in a tight range (Compl. +0.0154 to +0.0164, CR −3.79 to −4.40 points). highD mirrors Highway and rounD mirrors Roundabout in both ∣R∣|R| growth shape and Compl./CR convergence, indicating that the harness operates on factored variable signatures rather than scenario-specific surface features. Cross-domain transfer of the compiled memory itself is studied separately in Appendix D.7.

Case Study

Figure 9 compares trajectories of REINS, Plan-R1, LLaDA, and MPC on two scenarios, with activated rules and actions shown at each timestep. Rule definitions are provided in Appendix C.7.2.

Simulated Highway. REINS activates R03 and R07 at t=0t=0 to monitor the lead vehicle and adjacent lanes, triggers R12 at t=0.5st=0.5\mathrm{s} when a safe gap appears, executes a lane change at t=1.0st=1.0\mathrm{s}, and accelerates via R15 at t=1.5st=1.5\mathrm{s}, producing a smooth action sequence (IDLE→\toIDLE→\toRIGHT→\toFASTER). Plan-R1 applies all 15 rules simultaneously, causing conflicting constraints and repeated deceleration (SLOWER×3\times3) before a delayed maneuver.

Real-World highD. In the cut-in scenario, REINS detects lateral intrusion at t=0t=0 via R05, performs preemptive deceleration at t=0.5st=0.5\mathrm{s} using R07, and maintains safe distance until t=1.5st=1.5\mathrm{s} (IDLE→\toSLOWER→\toSLOWER→\toIDLE). Plan-R1 responds later with emergency braking at t=1.0st=1.0\mathrm{s} due to uniform rule execution.

Compiled Rule Database

Rule Database Statistics

Table 8 shows the distribution of variables by macro-group and rules by template type in REINS’s Neo4j graph database. The post-deployment database contains 1,023 rules covering six driving scenarios (four simulated: Highway, Merge, Roundabout, Intersection; two real-world: highD, rounD). IF-THEN and AND-THEN templates dominate due to the prevalence of conditional and multi-condition reasoning in driving. Intersection scenarios contain the most rules due to complex right-of-way interactions, while Highway scenarios require fewer given simpler lane-following dynamics. This scale is comparable to industrial rule-based systems while remaining tractable for O(log⁡n)O(\log n) graph database retrieval (<1<1 ms per query).

Figure 8 visualizes the graph structure of 200 randomly sampled rules from the database. Gray nodes are variables, blue nodes are rules, and pink nodes are the five discrete actions. Edge colors match source node colors: gray edges represent Variable→\toRule, while blue edges represent Rule→\toAction.

Figure 8. Graph structure of 200 randomly sampled rules.

Figure 9. Trajectory comparison across four methods on (a) simulated highway and (b) real-world highD scenarios.

Several structural patterns emerge from this visualization: (1) Variable sharing: A small set of variables (e.g., TTC, THW, speed) triggers a large number of rules, indicating that safety-critical variables serve as common preconditions across diverse driving scenarios. (2) Action concentration: The majority of rules converge to SLOWER and IDLE, which exhibit the highest in-degree among all five actions. This reflects the safety-first design principle where conservative actions are recommended under uncertain or risky conditions. In contrast, LANE_LEFT, LANE_RIGHT, and FASTER receive fewer rule connections, as these actions require more stringent preconditions. (3) Rule diversity: Despite action concentration, rules maintain diverse trigger conditions from different variables, enabling fine-grained context-aware activation rather than uniform rule application. These patterns support REINS’s retrieval strategy: variable-indexed queries efficiently activate relevant rule subsets, while action aggregation via noisy-OR naturally prioritizes safety-critical recommendations.

Representative Rules

Table 11 lists 15 representative rules from REINS’s compiled rule database. The full post-deployment Neo4j database contains 1,023 rules across six driving scenarios, from which context-relevant subsets are retrieved at runtime via parameterized Cypher queries. These rules are automatically compiled from LLM-generated linguistic descriptions and calibrated using the threshold calibration mechanism described in § 4.1.2. For fair comparison, Plan-R1 applies the same 15 representative rules uniformly at each step, while REINS selectively activates 2–3 context-relevant rules via the retrieval mechanism.

IDGuard Condition P(r)\mathcal{P}(r)Action ara_rTemplate
R01TTC <2.0s< 2.0\text{s}emergency brakeTHRESHOLD
R02vego>vlimit+5km/hv_{ego} > v_{limit} + 5\text{km/h}DEC to limitTHRESHOLD
R03THW <1.8s∨< 1.8\text{s} \lor DHW <25m< 25\text{m}DEC / maintain gapIF-THEN
R04TTC <3.5s∧< 3.5\text{s} \land DHW <40m< 40\text{m}DEC (moderate)AND-THEN
R05vadjlat>0.3m/s∧Δy<2mv_{adj}^{lat} > 0.3\text{m/s} \land\Delta y < 2\text{m}DEC (preemptive)AND-THEN
R06visibility <100m< 100\text{m}reduce speed 20%THRESHOLD
R07TTCadj<4s∨\mathrm{TTC}_{adj} < 4\text{s} \lor cut-inincrease headwayIF-THEN
R08lane_end <200m< 200\text{m}prepare mergeTEMPORAL-CHAIN
R09at_yield ∧\land traffic_presentyield / stopPRIORITY
R10pedestrian <30m< 30\text{m}DEC / prepare stopMULTI-ACTION
R11vlead<vego−10km/h∧gapadj>35mv_{lead} < v_{ego} - 10\text{km/h} \land gap_{adj} > 35\text{m}consider lane changeAND-THEN
R12gaptarget>30m∧TTCtarget>5sgap_{target} > 30\text{m} \land\mathrm{TTC}_{target} > 5\text{s}execute lane changeAND-THEN
R13in_lane_change ∧TTCnew<3s\land\mathrm{TTC}_{new} < 3\text{s}abort lane changeAND-THEN
R14merge_complete ∧\land DHW <20m< 20\text{m}DEC post-mergeAND-THEN
R15post_merge ∧vego<vflow−5km/h\land v_{ego} < v_{flow} - 5\text{km/h}ACC to flowAND-THEN

Table 11. Representative rules from the compiled rule database.

The 15 rules cover six of the seven template types defined in Definition 3.5: (1) THRESHOLD rules (R01, R02, R06) enforce numeric boundaries on physical variables such as TTC and speed; (2) IF–THEN rules (R03, R07) implement basic conditional logic with disjunctive guards; (3) AND–THEN rules (R04, R05, R11–R15) require multiple conditions to be satisfied simultaneously; (4) PRIORITY rules (R09) establish decision hierarchies for right-of-way scenarios; (5) MULTI-ACTION rules (R10) trigger compound actions under critical conditions; (6) TEMPORAL-CHAIN rules (R08) encode time-sensitive constraints for upcoming events. The complete definitions of all seven rule template types are provided in Appendix § 9.§ 2, and the conflict resolution mechanism is described in Appendix § 9.§ 3.

Fairness Protocol, Robustness, Transfer, and Scalability

This appendix collects the studies that scope the harness claim and stress the main results: the domain-specific versus domain-agnostic components of the harness (D.1), the baseline fairness protocol with a matched re-run and a common-reference compliance audit (D.2), the runtime profile of the PDDL baseline (D.3), robustness to the LLM backbone and to prompt variation (D.4), what rollout verification filters (D.5), reactive replay and observation noise (D.6), cross-domain memory transfer (D.7), the latency of the online-miss cycle and its scheduling (D.8), and retrieval at deployment scale (D.9). Unless stated otherwise, all studies use the Highway scenario, five seeds, and the protocol of § 5.1.

Scope of the Harness Claim

The three couplings are presented as a harness pattern, while the implementation is specialized to driving. Table 12 classifies each component of REINS and sketches the instantiation for a different trajectory-planning domain, robot-arm manipulation, whose action space is continuous and high-dimensional and whose safety notions (contact force, grasp stability) differ from driving. Two components are domain schemas that any instantiation must author; the remaining five transfer unchanged. The safety notion enters only through the variable schema and the terms of the objective JJ: calibrated predicates over contact-force variables are structurally identical to TTC guards, and the calibration procedure and the verification protocol do not change. The harness contribution lives in the five unchanged components; the two redesigned ones constitute the domain description that any planner for that domain must author anyway.

ComponentDriving (this paper)Manipulation (sketch)Transfer
Variable space and groups44 variables in Env, Traffic, Ego, Action, Outcomejoint angles and torques, end-effector pose, contact forces, object posesredesign
Action space5 driving meta-actionsskill primitives (reach, grasp, lift, place, retreat)redesign
Predicate grammar and thresholdsTTC and THW guardsforce-margin, slip, and grasp-stability guardsgrammar unchanged, thresholds recalibrated
Dynamics learningLLM prior, group-weighted ridge, per-variable Transformersame, retrained on domain dataunchanged
Verificationcollision and violation terms in JJcontact-force and stability terms in JJprotocol unchanged
Indexed memory and retrievalvariable-keyed graph schemasameunchanged
Acquisition loopmiss detection, proposal, verification, write-backsameunchanged

Table 12. Domain-specific and domain-agnostic components of the harness.

Baseline Fairness Protocol

Shared and unshared conditions. PDDL, DriReg, and LLaDA were conceived for symbolic planning domains, regulatory text, and driver handbooks respectively, none with a factored driving state, so each was re-implemented faithfully to its original design for closed-loop highway-env. Table 13 lists what is shared with REINS and what each method keeps by design. The shared conditions fix the observation space, action space, episodes, LLM backbone, and decoding; the unshared ones leave each method its own knowledge representation and thresholds, which leaves the rule-generation procedure as a confound. Three instruments below isolate the harness regardless.

ConditionPDDLDriRegLLaDA
Observation space, action space, episodessharedsharedshared
GPT-4o backbone (2024-08-06), temperature 0 for rule generationsharedsharedshared
44-variable vocabulary (Appendix A.1) in rule-generation promptsown vocabularyown vocabularyn/a (linguistic rules)
Threshold calibrationuncalibrateduncalibratedn/a (no thresholds)

Table 13. Fairness conditions for the rule-based baselines as published. “Own vocabulary” and “uncalibrated” follow each method’s original design.

Matched re-run. We regenerated the PDDL and DriReg rules over the same 44-variable vocabulary, passed their thresholds through REINS’s calibration pipeline, and re-evaluated (Table 14). Input normalization improves both baselines by 3–5 CR points and explains a minority of the gap; the majority survives it.

CR (%)PDDLPDDL matchedDriRegDriReg matchedREINS
Highway25.9321.3721.7618.925.67
Intersection32.1227.6429.8925.819.08

Table 14. Matched re-run: PDDL and DriReg rules regenerated over REINS’s variable vocabulary with calibrated thresholds.

Bracketing with the ablations. Two ablations from Table 2 bracket the remaining gap with the paper’s own numbers. Hand-crafted rules inside the full harness still reach CR 11.23% on Highway, better than every matched no-harness variant in Table 14 and close to the best baseline Plan-R1 at 12.83%. Conversely, applying REINS’s rules uniformly, the way the baselines use rules, raises CR by 22–43% and PE by 34–58%. Worse inputs with the harness keep most of the gain; the same inputs without the harness lose it.

Common-reference compliance. Compliance in Table 1 is measured against each method’s own rule set. Table 15 re-scores every method against REINS’s compiled rule set as a common reference.

MethodOwn rulesCommon reference (REINS set)
HighwayIntersectionHighwayIntersection
MPCn/an/a0.87120.8423
MCTSn/an/a0.88310.8517
DriveSpeakn/an/a0.82460.7912
LLaDAn/an/a0.84120.8104
PDDL0.91230.87890.88670.8621
DriReg0.94520.91530.90830.8874
SymAgent0.95610.92740.93120.9067
Plan-R10.97170.95530.94980.9231
REINS0.99560.98380.99560.9838

Table 15. Compliance against each method’s own rule set and against REINS’s compiled rule set as a common reference.

Compliance is a property of the executed trajectory rather than of the planner: at each step, the reference rules whose guards hold in the logged state become active, and a violation is counted when the logged behavior fails an active rule (Appendix § 10.§ 2). Each method therefore plans exactly as before and its trajectories are audited afterward, which is also how the four methods without native rule sets receive values. Because the reference set equals REINS’s planning set, REINS’s own value is unchanged by construction; the informative content is that the baseline ordering and the gaps persist.

Runtime Profile of the PDDL Baseline

The PDDL baseline follows the pipeline in which the LLM writes the domain’s preconditions and effects offline and a classical solver executes at runtime [12, 24]. The solver is Pyperplan [1], a Python STRIPS planner invoked in process at each decision step; there is no per-step LLM call. Its 4.95 ms per step on Highway (Table 1) decomposes into grounding 3.71 ms, search 0.94 ms, and plan extraction 0.30 ms. The solver re-instantiates every precondition against the current state at every step with no indexing, so grounding takes roughly three quarters of the budget. REINS avoids exactly this cost: variable-indexed retrieval touches 2–3 rules in under 1 ms, followed by a fixed-size rollout at H=5H=5. This is the architectural payoff of consolidation with indexing.

Robustness to the LLM Backbone and to Prompt Variation

The LLM produces the dependency priors, the rule structures, and the Cypher queries, so we regenerate the whole offline pipeline with two further backbones and with three paraphrases of the dependency and rule-extraction prompts (Table 16). Rule structure varies mildly across backbones and paraphrases, while the calibrated thresholds and the final behavior barely move. The LLM picks variables, templates, and actions; calibration re-anchors every numeric threshold to data, so backbone differences wash out at the threshold level. Malformed or unsafe proposals never reach memory, because rollout verification rejects them regardless of which backbone or prompt produced them.

Variation (Highway)Rule overlap with GPT-4oThreshold shift after calibrationCompl.CR (%)
GPT-4o (paper)n/an/a0.99565.67
Claude Sonnet 4.587.3%3.2%0.99485.89
Qwen2.5-72B-Instruct81.6%3.8%0.99316.24
Three prompt paraphrases, GPT-4o91.2–94.6%——5.58–5.91

Table 16. Robustness of the compiled rules and of closed-loop behavior to the LLM backbone and to prompt paraphrases.

What Rollout Verification Filters

On the 1000-episode Highway deployment of § 5.4, applying the windowed call rates of Table 3 to the 100,000 deployment steps yields roughly 39,000 logged proposals (an arithmetic consequence of the call rates, not an independent count). Of these, 2.1% failed schema validation, 18.0% were rejected by rollout verification, and 79.9% were accepted. Acceptances overwhelmingly hash-collide with rules already in memory (Eq. (8)) and only update confidences; they deduplicate to the 57 unique rules that grow the memory from 88 to 145. A manual audit of the 57 unique rules judged 54 consistent with domain guidelines; the three flagged rules were over-specific and never activated again. Episodes in which at least one acquired rule fired show no elevated collision rate against episodes in which none fired (5.4% against 5.8%).

Three properties of the design bound what a plausible but incorrect proposal can do. Verification errs toward rejection: a rule is accepted only if every calibrated predicate holds along the predicted horizon (Eq. (7)), so dynamics error costs availability rather than safety in the common case. Accepted rules never bypass the runtime loop: every executed action is re-verified by rollout at decision time (§ 4.2.1), so a wrongly accepted rule must also survive the per-step check before it can affect control. Finally, the residual dependence on dynamics fidelity is stated in § 6.

Reactive Replay and Observation Noise

Reactive replay. In the four simulated scenarios the surrounding vehicles already react to the ego through IDM car-following with MOBIL lane changes. The real-world rows keep highD and rounD as recorded so that they reflect human behavior rather than a simulator’s. To measure the effect of this choice, a reactive-replay variant on highD switches recorded vehicles within 50 m of the ego to IDM once interaction occurs, following the reactive closed-loop protocol of nuPlan [2]. REINS CR moves from 6.12% to 6.94% while Plan-R1 moves from 12.78% to 15.36%, so the gap to the strongest baseline widens.

Observation noise. We corrupt the observed variables with zero-mean Gaussian noise scaled to each variable’s standard deviation and, separately, drop 5% of frames (Table 17). Calibrated thresholds carry a data-derived margin and every action is vetted by a multi-step rollout rather than by a single reading, so REINS degrades more slowly than the strongest baseline at every level, with Compl. staying at or above 0.987. Full-stack perception errors (occlusion, tracking identity switches, map errors) remain out of scope.

CR (%) on Highwayno noise2.5% noise5% noise10% noise5% frame drops
REINS5.675.926.518.146.88
Plan-R112.8313.7115.4219.8716.50

Table 17. Collision rate under σ\sigma-scaled Gaussian observation noise and under frame drops.

Cross-Domain Memory Transfer

We test how the memory behaves when the offline data are domain-shifted, using the checkpoint protocol of Table 3. Setting A compiles R0\mathcal{R}_0 solely from highD and rounD (whose memories total 187 rules before merging and content-hash deduplication) and deploys on highway-env; Setting B compiles it solely from the four simulated scenarios (432 rules before deduplication) and deploys on highD and rounD. Table 18 reports the ep. 250 and ep. 1000 endpoints of each setting, together with a frozen-transfer control on Highway; the native reference rows come from Table 3 and Table 10.

ScenarioCheckpoint∣R∣\lvert\mathcal{R}\rvertLLM Call (%)Compl. (↑)CR (%) (↓)
Mergeep. 25013671.360.98588.20
ep. 50015349.120.98937.35
ep. 75016726.480.99127.05
ep. 1000 (final)17513.920.99246.86
Frozen R0\mathcal{R}_0 (1000-ep eval)105—0.977010.65
Roundaboutep. 25014473.840.985210.55
ep. 50016252.200.98889.85
ep. 75017628.360.99109.40
ep. 1000 (final)18515.240.99259.01
Frozen R0\mathcal{R}_0 (1000-ep eval)112—0.977013.40
Intersectionep. 25016478.520.974210.85
ep. 50018457.640.97899.95
ep. 75020033.080.98179.45
ep. 1000 (final)21018.760.98389.08
Frozen R0\mathcal{R}_0 (1000-ep eval)127—0.962013.95
highDep. 25010768.240.98037.45
ep. 50012147.560.98386.65
ep. 75013124.120.98566.32
ep. 1000 (final)13812.360.98676.12
Frozen R0\mathcal{R}_0 (1000-ep eval)84—0.97129.95
rounDep. 25013274.680.978510.95
ep. 50014953.400.982110.20
ep. 75016229.720.98429.78
ep. 1000 (final)17016.080.98569.45
Frozen R0\mathcal{R}_0 (1000-ep eval)103—0.969213.85

Table 10. Self-evolution dynamics across the remaining evaluation scenarios. Same metrics and checkpoints as Table 3; the Frozen row runs the same 1000-episode window with acquisition disabled and exposes ∣R0∣\lvert\mathcal{R}_0\rvert.

ScenarioCheckpoint∣R∣\lvert R\rvertLLM Call (%)Compl.CR (%)PE (ms)
Setting A: R0R_0 from highD and rounD, deployed on highway-env
Highwayep. 25026586.20.961211.842.71
Highwayep. 100034914.90.99146.212.54
Highwayep. 1000, acquisition frozen———11.20—
Highwaynative, ep. 100014512.810.99565.672.50
Intersectionep. 25028791.30.948715.624.87
Intersectionep. 100039117.20.978210.134.66
Intersectionnative, ep. 100021012.810.98389.084.58
Setting B: R0R_0 from the four simulated scenarios, deployed on highD and rounD
highDep. 25047171.40.97029.872.79
highDep. 100050813.60.98386.792.68
highDnative, ep. 100013812.810.98676.122.62
rounDep. 25047879.80.964514.214.12
rounDep. 100051715.10.982110.243.97
rounDnative, ep. 100017012.810.98569.453.89

Table 18. Cross-domain memory transfer under the checkpoint protocol of Table 3. The frozen-transfer row disables acquisition after transfer; only its CR was recorded.

A domain-shifted memory starts degraded: at ep. 250 the call rate runs 86.2% on Highway against the native 70.0% of Table 3, and CR runs several points above the native value at the same checkpoint (11.84% against 7.05%). Acquisition recovers most of the gap within 1000 episodes: final CR lands within 0.5–1.1 points of native and Compl. within 0.003–0.006. On Highway, freezing the transferred memory prevents recovery: at ep. 1000 the frozen transfer stays at CR 11.20% against 6.21% with acquisition enabled, so the recovery comes from verification-gated acquisition rather than from the transferred rules themselves, mirroring the native pattern of Table 3, where frozen R0\mathcal{R}_0 ends at CR 9.63% against the evolved 5.67%. Sim-to-real shows slightly smaller residual gaps and lower final call rates than real-to-sim; one plausible factor is its larger source memory (432 against 187 rules before deduplication).

The initial call rate of 86.2% also shows that most of the source-domain memory is not functionally reusable zero-shot in a new but still driving context. This is consistent with the safety-oriented design: thresholds are calibrated to the source-domain distribution, so under shift the harness re-invokes and re-verifies rather than reusing rules whose calibration may no longer hold. We therefore do not frame these results as evidence of strong zero-shot generalization; the limitation is stated in § 6.

Latency of the Online-Miss Cycle and Its Scheduling

What PE counts. For every method, PE measures the synchronous action-selection computation per step. In the evaluated closed-loop setting, a miss completes proposal, verification, and write-back within the step while simulation time is paused, so the reported PE excludes the acquisition pipeline, namely the LLM call together with the subsequent parsing, calibration, verification, and write-back. Table 19 profiles each stage.

StageMeanp95Deployment scheduling
Fallback action for the current step2.6 ms3.9 mscontrol path, within budget
Prompt assembly and state serialization0.9 ms1.4 msbackground
LLM rule proposal (GPT-4o API)1.58 s2.94 sbackground
Parsing and schema validation2.1 ms3.0 msbackground
Threshold calibration on the sliding window1.3 ms1.9 msbackground
Rollout verification at H=5H=51.6 ms2.2 msbackground
Neo4j insert and index update4.7 ms6.8 msbackground
Full cycle, miss to usable rule1.59 s2.96 sbackground

Table 19. Latency of the online-miss cycle on Highway. The fallback row sits on the control path and is not part of the full-cycle latency; the acquisition stages below it sum to the full-cycle row.

Deployment scheduling. The cycle takes 1.59 s mean, dominated by the LLM call; the acquisition stages other than the LLM call total about 11 ms. In deployment the cycle moves off the critical path by construction, because the planner has a defined behavior without the acquired rule: the best action over the retrieved rules or, with empty retrieval, the safe action that maximizes minimum lookahead TTC (Eq. (24)) together with a human-takeover alert. The current step executes that fallback while the cycle completes in the background, and the acquired rule serves later encounters. At 5 Hz the acquisition window spans about eight control cycles, during which the planner behaves as a verified conservative planner. Figure 10 contrasts the evaluated schedule with the deployment schedule.

Dataflow of the online-miss cycle: Evaluated (sim. paused): retrieve miss → LLM proposal 1.58 s → calibrate + verify, 3 ms → write-back 5 ms → act $a_t^*$; Deployment (control path): retrieve miss → fallback safe $a_t^s$ 2.6 ms → step $t+1$ → step $t+8$ memory hit; Deployment (background): LLM proposal 1.58 s → calibrate + verify, 3 ms → write-back 5 ms. PE counts only the control-path boxes.

Figure 10. Dataflow of the online-miss cycle. Top: in the evaluated closed-loop setting the cycle completes within the step while simulation time is paused, and PE counts only the synchronous control-path computation. Bottom: in deployment the current step executes the verified fallback while the cycle runs in the background (about eight control cycles at 5 Hz), and the acquired rule serves later encounters.

Retrieval and Aggregation at Deployment Scale

As memory grows, retrieval and multi-rule aggregation must stay within the control window. The stress test runs on Highway and varies only the database size, inflating it with synthetic rules generated as variable and threshold perturbations of compiled rules that preserve the schema and the trigger-degree distribution (Table 20). Retrieval stays sub-millisecond and grows slowly with memory size, from 0.41 ms at the paper’s 1,023 rules to 0.79 ms at one hundred thousand, consistent with indexed lookup rather than linear scanning. Conflict aggregation does not grow with the database: retrieval returns at most k=10k=10 rules regardless of memory size, so noisy-OR aggregation (Eq. (5)) and the arbitration of Appendix § 9.§ 3 cost O(k)O(k). On the online planning path, the database-size-dependent cost therefore concentrates in retrieval; index maintenance and write costs sit on the acquisition path, off the control loop.

Memory size1,023 (paper)10,00050,000100,000
Cypher retrieval (ms)0.410.550.680.79
End-to-end PE (ms)2.502.642.772.88

Table 20. Retrieval latency and end-to-end PE on Highway as the rule memory is inflated with schema-preserving synthetic rules.

References

  1. [1]Yusra Alkhazraji, Matthias Frorath, Markus Grützner, Malte Helmert, Thomas Liebetraut, Robert Mattmüller, Manuela Ortlieb, Jendrik Seipp, Tobias Springenberg, Philip Stahl, and Jan Wülfing. Pyperplan. Zenodo, https://doi.org/10.5281/zenodo.3700819, 2020.
  2. [2]Holger Caesar, Juraj Kabzan, Kok Seang Tan, Whye Kit Fong, Eric Wolff, Alex Lang, Luke Fletcher, Oscar Beijbom, and Sammy Omari. nuPlan: A closed-loop ML-based planning benchmark for autonomous vehicles. arXiv preprint arXiv:2106.11810, 2021.arxiv.org/abs/2106.11810
  3. [3]Tianhui Cai, Yifan Liu, Zew ei Zhou, Haoxuan Ma, Seth Z. Zhao, Zhiwen Wu, Xu Han, Zhiyu Huang, and Jiaq i Ma. Driving with regulation: Trustworthy and interpretable decision-making for autonomous driving with retrieval-augmented reasoning. arXiv preprint arXiv:2410.04759, 2024.arxiv.org/abs/2410.04759
  4. [4]Haoqiang Chen, Jianxiang Sun, Yadong Liu, Zhiyong Peng, and Dewen Hu. Causal confusion in pedestrian crossing intention prediction for autonomous vehicles: The role of ego-vehicle speed. IEEE Transactions on Intelligent Transportation Systems, 2025.DOI
  5. [5]Can Cui, Yunsheng Ma, Xu Cao, Wenqian Ye, and Ziran Wang. Drive as you speak: Enabling human-like interaction with large language models in autonomous vehicles. In Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision, pages 902–909, 2024.arxiv.org/abs/2309.10228
  6. [6]Zhihong Cui, Haoran Tang, Tianyi Li, Yushuai Li, Peiyuan Guan, Amir Taherkordi, and Tor Skeie. C-TRAIL: A commonsense world framework for trajectory planning in autonomous driving. IEEE Transactions on Vehicular Technology, 2026.arxiv.org/abs/2603.29908
  7. [7]Paolo Falcone, Francesco Borrelli, Jahan Asgari, Hongtei Eric Tseng, and Davor Hrovat. Predictive active steering control for autonomous vehicle systems. IEEE Transactions on Control Systems Technology, 15(3):566–580, 2007.DOI
  8. [8]Nadime Francis, Alastair Green, Paolo Guagliardo, Leonid Libkin, Tobias Lindaaker, Victor Marsault, Stefan Plantikow, Mats Rydberg, Petra Selmer, and Andrés Taylor. Cypher: An evolving query language for property graphs. In Proceedings of the 2018 International Conference on Management of Data, pages 1433–1445, 2018.DOI
  9. [9]Daocheng Fu, Xin Li, Licheng Wen, Min Dou, Pinlong Cai, Botian Shi, and Yu Qiao. Drive like a human: Rethinking autonomous driving with large language models. In IEEE/CVF Winter Conference on Applications of Computer Vision Workshops (WACVW), pages 910–919, 2024.arxiv.org/abs/2307.07162
  10. [10]Douglas Gettman and Larry Head. Surrogate safety measures from traffic simulation models. Transportation Research Record, 1840(1):104–115, 2003.DOI
  11. [11]Luca Giamattei, Antonio Guerriero, Roberto Pietrantuono, and Stefano Russo. Causality-driven testing of autonomous driving systems. ACM Transactions on Software Engineering and Methodology, 33(3):1–35, 2024.DOI
  12. [12]Lin Guan, Karthik Valmeekam, Sarath Sreedharan, and Subbarao Kambhampati. Leveraging pre-trained large language models to construct and utilize world models for model-based task planning. In Advances in Neural Information Processing Systems, volume 36, 2023.arxiv.org/abs/2305.14909
  13. [13]Arthur E Hoerl and Robert W Kennard. Ridge regression: Biased estimation for nonorthogonal problems. Technometrics, 12(1):55–67, 1970.
  14. [14]Arne Kesting, Martin Treiber, and Dirk Helbing. General lane-changing model MOBIL for car-following models. Transportation Research Record, 1999(1):86–94, 2007.DOI
  15. [15]Robert Krajewski, Julian Bock, Laurent Kloeker, and Lutz Eckstein. The highD dataset: A drone dataset of naturalistic vehicle trajectories on German highways for validation of highly automated driving systems. In 2018 21st International Conference on Intelligent Transportation Systems (ITSC), pages 2118–2125. IEEE, 2018.arxiv.org/abs/1810.05642
  16. [16]Robert Krajewski, Tobias Moers, Julian Bock, Lennart Vater, and Lutz Eckstein. The rounD dataset: A drone dataset of road user trajectories at roundabouts in Germany. In 2020 IEEE 23rd International Conference on Intelligent Transportation Systems (ITSC), pages 1–6. IEEE, 2020.DOI
  17. [17]Yoonho Lee, Roshen Nair, Qizheng Zhang, Kangwook Lee, Omar Khattab, and Chelsea Finn. Meta-harness: End-to-end optimization of model harnesses. In CoRR abs/2603.28052, 2026.arxiv.org/abs/2603.28052
  18. [18]David Lenz, Tobias Kessler, and Alois Knoll. Tactical cooperative planning for autonomous highway driving using Monte-Carlo tree search. In 2016 IEEE Intelligent Vehicles Symposium (IV), pages 447–453. IEEE, 2016.
  19. [19]Edouard Leurent. An environment for autonomous driving decision-making. https://github.com/eleurent/highway-env, 2018.DOI
  20. [20]Boyi Li, Yue Wang, Jiageng Mao, Boris Ivanovic, Sushant Veer, Karen Leung, and Marco Pavone. Driving everywhere with large language model policy adaptation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 14948–14957, 2024a.arxiv.org/abs/2402.05932
  21. [21]Yiheng Li, Cunxin Fan, Chongjian Ge, Zhihao Zhao, Chenran Li, Chenfeng Xu, Huaxiu Yao, Masayoshi Tomizuka, Bolei Zhou, Chen Tang, Mingyu Ding, and Wei Zhan. WOMD-Reasoning: A large-scale dataset for interaction reasoning in driving. arXiv preprint arXiv:2407.04281, 2024b.arxiv.org/abs/2407.04281
  22. [22]Yuxuan Liang, Kun Ouyang, Yiwei Wang, Xu Liu, Hongyang Chen, Junbo Zhang, Yu Zheng, and Roger Zimmermann. TrajFormer: Efficient trajectory classification with transformers. In Proceedings of the 31st ACM International Conference on Information & Knowledge Management, pages 1229–1237, 2022.DOI
  23. [23]Ben Liu, Jiahai Zhang, Fangquan Lin, Cheng Yang, Min Peng, and Wotao Yin. SymAgent: A neural-symbolic self-learning agent framework for complex reasoning over knowledge graphs. In Proceedings of the ACM on Web Conference 2025, pages 98–108, 2025.arxiv.org/abs/2502.03283
  24. [24]Bo Liu, Yuqian Jiang, Xiaohan Zhang, Qiang Liu, Shiqi Zhang, Joydeep Biswas, and Peter Stone. LLM+P: Empowering large language models with optimal planning proficiency. arXiv preprint arXiv:2304.11477, 2023.arxiv.org/abs/2304.11477
  25. [25]Linhao Luo, Zicheng Zhao, Gholamreza Haffari, Yuan-Fang Li, Chen Gong, and Shirui Pan. Graph-constrained reasoning: Faithful reasoning on knowledge graphs with large language models. arXiv preprint arXiv:2410.13080, 2024.arxiv.org/abs/2410.13080
  26. [26]Yecheng Jason Ma, William Liang, Guanzhi Wang, De-An Huang, Osbert Bastani, Dinesh Jayaraman, Yuke Zhu, Linxi Fan, and Anima Anandkumar. Eureka: Human-level reward design via coding large language models. In ICLR, 2024.arxiv.org/abs/2310.12931
  27. [27]Kumar Manas, Stefan Zwicklbauer, and Adrian Paschke. TR2MTL: LLM based framework for metric temporal logic formalization of traffic rules. In 2024 IEEE Intelligent Vehicles Symposium (IV), pages 1206–1213. IEEE, 2024.DOI
  28. [28]Kumar Manas, Mert Keser, and Alois Knoll. Integrating legal and logical specifications in perception, prediction, and planning for automated driving: A survey of methods. arXiv preprint arXiv:2510.25386, 2025.arxiv.org/abs/2510.25386
  29. [29]Jiageng Mao, Junjie Ye, Yuxi Qian, Marco Pavone, and Yue Wang. A language agent for autonomous driving. In First Conference on Language Modeling (COLM), 2024.arxiv.org/abs/2311.10813
  30. [30]Mike A. Merrill, Alexander G. Shaw, Nicholas Carlini, Boxuan Li, Harsh Raj, Ivan Bercovich, Lin Shi, Jeong Yeon Shin, Thomas Walshe, E. Kelly Buchanan, et al. Terminal-bench: Benchmarking agents on hard, realistic tasks in command line interfaces. In CoRR abs/2601.11868, 2026.arxiv.org/abs/2601.11868
  31. [31]Henry Montgomery. Decision rules and the search for a dominance structure: Towards a process model of decision making. In Advances in Psychology, volume 14, pages 343–369. Elsevier, 1983.
  32. [32]Brian Paden, Michal Čáp, Sze Zheng Yong, Dmitry Yershov, and Emilio Frazzoli. A survey of motion planning and control techniques for self-driving urban vehicles. IEEE Transactions on Intelligent Vehicles, 1(1):33–55, 2016.arxiv.org/abs/1604.07446
  33. [33]Jonas Peters, Dominik Janzing, and Bernhard Schölkopf. Elements of Causal Inference: Foundations and Learning Algorithms. The MIT Press, 2017.
  34. [34]Stefan Riedmaier, Thomas Ponn, Dieter Ludwig, Bernhard Schick, and Frank Diermeyer. Survey on scenario-based safety assessment of automated vehicles. IEEE Access, 8:87456–87477, 2020.DOI
  35. [35]Hao Sha, Yao Mu, Yuxuan Jiang, Li Chen, Chenfeng Xu, Ping Luo, Shengbo Eben Li, Masayoshi Tomizuka, Wei Zhan, and Mingyu Ding. LanguageMPC: Large language models as decision makers for autonomous driving. arXiv preprint arXiv:2310.03026, 2023.arxiv.org/abs/2310.03026
  36. [36]Shai Shalev-Shwartz, Shaked Shammah, and Amnon Shashua. On a formal model of safe and scalable self-driving cars. arXiv preprint arXiv:1708.06374, 2017.
  37. [37]Xiaolong Tang, Meina Kan, Shiguang Shan, and Xilin Chen. Plan-R1: Safe and feasible trajectory planning as language modeling. arXiv preprint arXiv:2505.17659, 2025.arxiv.org/abs/2505.17659
  38. [38]Martin Treiber, Ansgar Hennecke, and Dirk Helbing. Congested traffic states in empirical observations and microscopic simulations. Physical Review E, 62(2):1805–1824, 2000.DOI
  39. [39]Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, volume 30, 2017.arxiv.org/abs/1706.03762
  40. [40]Guanzhi Wang, Yuqi Xie, Yunfan Jiang, Ajay Mandlekar, Chaowei Xiao, Yuke Zhu, Linxi Fan, and Anima Anandkumar. Voyager: An open-ended embodied agent with large language models. In CoRR abs/2305.16291, 2023.arxiv.org/abs/2305.16291
  41. [41]Yucen Wang, Rui Yu, Shenghua Wan, Le Gan, and De-Chuan Zhan. FOUNDER: Grounding foundation models in world models for open-ended embodied decision making. In Forty-Second International Conference on Machine Learning, 2025.arxiv.org/abs/2507.12496
  42. [42]Jim Webber. A programmatic introduction to Neo4j. In Proceedings of the 3rd Annual Conference on Systems, Programming, and Applications: Software for Humanity, pages 217–218, 2012.DOI
  43. [43]Fanzhi Zeng, Siqi Wang, Chuzhao Zhu, and Li Li. ADRD: LLM-driven autonomous driving based on rule-based decision systems. arXiv preprint arXiv:2506.14299, 2025.arxiv.org/abs/2506.14299
  44. [44]Mingliang Zhai, Cheng Li, Zengyuan Guo, Ningrui Yang, Xiameng Qin, Sanyuan Zhao, Junyu Han, Ji Tao, Yuwei Wu, and Yunde Jia. World knowledge-enhanced reasoning using instruction-guided interactor in autonomous driving. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 39, pages 9842–9850, 2025.arxiv.org/abs/2412.06324
  45. [45]Jiahui Zhang, Zhiqiang Jian, Jiawei Fu, Zhixiong Nan, Jingmin Xin, and Nanning Zheng. Trajectory planning with comfort and safety in dynamic traffic scenarios for autonomous driving. In 2021 IEEE Intelligent Vehicles Symposium Workshops (IV Workshops), pages 342–349. IEEE, 2021a.DOI
  46. [46]Lunjun Zhang, Ge Yang, and Bradly C Stadie. World model as a graph: Learning latent landmarks for planning. In International Conference on Machine Learning, pages 12611–12620. PMLR, 2021b.arxiv.org/abs/2011.12491
  47. [47]Yuhang Zhang, Jiaqi Liu, Chengkai Xu, Peng Hang, and Jian Sun. LeAD: The LLM enhanced planning system converged with end-to-end autonomous driving. In CoRR abs/2507.05754, 2025.arxiv.org/abs/2507.05754
  48. [48]Andrew Zhao, Daniel Huang, Quentin Xu, Matthieu Lin, Yong-Jin Liu, and Gao Huang. ExpeL: LLM agents are experiential learners. In AAAI, 2024.arxiv.org/abs/2308.10144

Paper details

vlnc:W_xt99qm4z
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents