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.

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 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 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 : are observable variables (e.g., TTC, THW, DHW, ego_speed, lead_speed, road_friction); groups them by semantic role [4]; assigns each variable to a group; and specifies permissible group-level dependencies (Eq. (10) in Appendix § 9.§ 1).
Definition 3.2 (State and Action Spaces). The state is a complete variable assignment. The action space 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 with , where edges are admissible only if [11]. A dynamics function set predicts each variable from its parents over a temporal lag [33]:
An -step rollout from under yields .
Rule Representation
Definition 3.4 (Predicate). A predicate is a Boolean function with comparison operator and threshold .
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 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 with template , guard predicates , recommended action , and confidence . Activation requires all guards to hold:
Problem Definition
Definition 3.7 (Self-Evolving Agent Harness for Trajectory Planning). Let be a driving dataset and a pre-trained LLM. The harness problem is to construct , where are learned from with priors from (Def. 3.3), is an indexed rule memory compiled offline from (Def. 3.6), and is a policy that, at each , retrieves and proceeds as follows:
(hit) if , scores actions over and verifies them by rollout under within a real-time budget;
(miss) otherwise, proposes a candidate commitment, which is grounded via and verified by rollout; if all predicates pass, the commitment is compiled into a rule and .
The parameters of remain unchanged, and is monotone non-decreasing; under stationarity of the scene distribution, the per-scene LLM invocation rate is non-increasing.
Methodology
REINS realizes the harness as a two-phase system (Figure 2). Offline Preparation (§ 4.1) prepares the world dynamics for grounding and an initial rule memory for offline consolidation. Online Runtime (§ 4.2) executes a per-scene loop: rule-guided planning performs retrieval, scoring, and verification over , and online rule acquisition handles memory misses by querying and writing verified rules back to , closing the self-evolution loop.

Figure 2. The REINS framework. Phase 1 (offline): learn dynamics , and compile rules into initial memory . 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 , closing the self-evolution loop without any LLM weight update.
Offline Preparation
World Dynamics Learning
This module realizes grounding: we jointly learn dependency graph and dynamics functions 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 for each candidate edge (Appendix § 9.§ 5); combined with macro-group constraints (Eq. (10)), the unified prior is . For each , prior-guided ridge regression [13] predicts its value from lagged neighbors with adaptive penalty , so high-prior edges are weakly regularized:
retains the top- variables by , yielding and weights .
Dynamics Functions. Given , each is a multi-head Transformer [39] trained to predict from 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 , the LLM generates a rule (Eq. (15)) with template (Def. 3.5), guard predicates with symbolic thresholds, recommended action , and confidence derived from edge weight (prompts in Appendix § 9.§ 5).
Threshold Calibration. Each predicate’s threshold is calibrated from in three forms [25]—-score , quantile , or absolute constant —and the comparison operator is selected to maximize separability of safety outcome :
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 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 , active variables trigger parameterized Cypher queries [8] generated by the LLM (read-only, schema-constrained; Appendix § 9.§ 5). The retrieval map (Eq. (17)) returns up to rules ranked by confidence, restricted to triggers whose dependency direction respects the macro-group constraints.
Action Scoring. For each activated via Eq. (2), a Transformer-based scorer [22] produces relevance and action preference , yielding combined score (Eqs. (18)–(19); training loss in Eq. (20)). Multiple rules recommending action , denoted , are aggregated by noisy-OR:
The full normalized form and argmax decoder are in Appendix § 9.4.3.
Trajectory Verification. The learned dynamics verifies safety via forward rollout. For the top- actions ranked by , we predict -step trajectories via (Eq. (22)), and select , where 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 with an additional confidence guard against weakly supported matches:
with tuned threshold .
Rule Proposal and Online Verification. On a miss, proposes (Eq. (23)) conforming to Defs. 3.4–3.5 (Appendix § 9.§ 5). Symbolic thresholds in are calibrated on a sliding window so they track the current distribution. The harness then rolls out from under and accepts iff every predicate holds along the rollout:
On rejection the planner falls back to over if ; otherwise the harness raises a human-takeover alert and executes the safest action under by maximizing minimum lookahead TTC (Eq. (24) in Appendix § 9.4.4).
Memory Update. Accepted is keyed by content hash and inserted into Neo4j; on collision, confidences are averaged instead of duplicating the node:
The collision-branch rationale (averaging vs. duplication, exclusion of from ) is in Appendix § 9.4.4.
Self-Evolution Properties. Eq. (8) structurally enforces (memory monotonicity) and (no LLM update). Under stationarity of the scene distribution, the per-state miss rate is non-increasing as accumulates coverage:
so the per-scene LLM invocation rate decays monotonically with (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.
| Dataset | Scenario | Metric | DriveSpeak | LLaDA | MPC | MCTS | PDDL | DriReg | SymAgent | Plan-R1 | REINS |
| Simulation | Hig. | Compl. (↑) | - | - | - | - | 0.9123 | 0.9452 | 0.9561 | 0.9717 | 0.9956 |
| Simulation | Hig. | RE (↑) | -6.0360 | -5.8537 | -5.5613 | -5.2311 | -4.7868 | -4.1282 | -3.8662 | -3.5623 | 0.5228 |
| Simulation | Hig. | CR (↓, %) | 38.28 | 35.51 | 14.27 | 16.76 | 25.93 | 21.76 | 16.52 | 12.83 | 5.67 |
| Simulation | Hig. | PE (↓, ms) | 5.8921 | 5.2995 | 2.4742 | 2.3591 | 4.9521 | 4.3127 | 3.9621 | 3.7391 | 2.4998 |
| Simulation | Mer. | Compl. (↑) | - | - | - | - | 0.9011 | 0.9382 | 0.9572 | 0.9641 | 0.9924 |
| Simulation | Mer. | RE (↑) | -5.5730 | -5.2621 | -5.3891 | -5.1890 | -4.7129 | -4.1067 | -3.5622 | -3.1023 | -0.0400 |
| Simulation | Mer. | CR (↓, %) | 35.62 | 22.84 | 27.91 | 23.64 | 21.52 | 20.56 | 16.83 | 14.78 | 6.86 |
| Simulation | Mer. | PE (↓, ms) | 5.2120 | 4.3615 | 1.7354 | 1.6526 | 3.8549 | 2.8122 | 2.5697 | 2.2418 | 1.8928 |
| Simulation | Rou. | Compl. (↑) | - | - | - | - | 0.8838 | 0.9129 | 0.9411 | 0.9568 | 0.9925 |
| Simulation | Rou. | RE (↑) | -7.6873 | -7.1069 | -6.7722 | -6.5113 | -6.4895 | -6.3457 | -6.2313 | -6.0256 | -0.5444 |
| Simulation | Rou. | CR (↓, %) | 39.19 | 36.63 | 24.27 | 21.62 | 23.84 | 25.13 | 24.74 | 18.57 | 9.01 |
| Simulation | Rou. | PE (↓, ms) | 8.2673 | 7.6541 | 4.2134 | 4.0267 | 5.3793 | 5.1682 | 5.0713 | 4.8621 | 3.6243 |
| Simulation | Int. | Compl. (↑) | - | - | - | - | 0.8789 | 0.9153 | 0.9274 | 0.9553 | 0.9838 |
| Simulation | Int. | RE (↑) | -7.9740 | -7.5800 | -7.1345 | -7.0273 | -6.9792 | -6.7632 | -6.3314 | -6.0322 | -0.5747 |
| Simulation | Int. | CR (↓, %) | 44.27 | 42.22 | 25.38 | 23.78 | 32.12 | 29.89 | 25.34 | 20.37 | 9.08 |
| Simulation | Int. | PE (↓, ms) | 10.9324 | 9.3549 | 4.9653 | 4.7519 | 6.7682 | 6.2793 | 5.9932 | 5.5733 | 4.5807 |
| Real-world | highD | Compl. (↑) | - | - | - | - | 0.9078 | 0.9289 | 0.9423 | 0.9612 | 0.9867 |
| Real-world | highD | RE (↑) | -5.8234 | -5.5127 | -5.2891 | -5.0124 | -4.6523 | -4.2178 | -3.7856 | -3.4521 | 0.3847 |
| Real-world | highD | CR (↓, %) | 35.21 | 32.87 | 18.34 | 19.56 | 23.12 | 20.89 | 17.23 | 12.78 | 6.12 |
| Real-world | highD | PE (↓, ms) | 6.1234 | 5.5672 | 2.6123 | 2.4891 | 5.1234 | 4.5623 | 4.1234 | 3.8912 | 2.6234 |
| Real-world | rounD | Compl. (↑) | - | - | - | - | 0.8956 | 0.9187 | 0.9378 | 0.9534 | 0.9856 |
| Real-world | rounD | RE (↑) | -7.4521 | -6.9834 | -6.5123 | -6.2478 | -6.1234 | -5.8912 | -5.6234 | -5.3178 | -0.4123 |
| Real-world | rounD | CR (↓, %) | 41.23 | 38.56 | 25.34 | 23.12 | 26.78 | 24.23 | 20.89 | 18.47 | 9.45 |
| Real-world | rounD | PE (↓, ms) | 8.5621 | 7.8923 | 4.3521 | 4.1234 | 5.6234 | 5.2178 | 4.8912 | 4.5623 | 3.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 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.
| Metric | w/o World | w/o LLM Prior | w/o Rule Generation | w/o Retrieval | Full | |
| Hig. | Compl. (↑) | 0.9521 | 0.9628 | 0.9312 | 0.9845 | 0.9956 |
| Hig. | RE (↑) | -1.9234 | -1.5390 | -2.4156 | -0.8921 | 0.5228 |
| Hig. | CR (↓,%) | 8.47 | 8.26 | 11.23 | 8.12 | 5.67 |
| Hig. | PE (↓, ms) | 2.9532 | 2.6831 | 2.5124 | 3.8921 | 2.4998 |
| Mer. | Compl. (↑) | 0.9687 | 0.9738 | 0.9198 | 0.9812 | 0.9924 |
| Mer. | RE (↑) | -1.5621 | -1.2619 | -2.1893 | -0.7234 | -0.0400 |
| Mer. | CR (↓,%) | 9.23 | 9.08 | 12.87 | 8.89 | 6.86 |
| Mer. | PE (↓, ms) | 2.6234 | 2.1832 | 1.9021 | 2.9834 | 1.8928 |
| Rou. | Compl. (↑) | 0.9534 | 0.9611 | 0.9087 | 0.9756 | 0.9925 |
| Rou. | RE (↑) | -2.3456 | -1.1783 | -3.1234 | -1.2134 | -0.5444 |
| Rou. | CR (↓,%) | 12.34 | 11.84 | 15.89 | 11.23 | 9.01 |
| Rou. | PE (↓, ms) | 4.1245 | 3.8011 | 3.6521 | 5.2134 | 3.6243 |
| Int. | Compl. (↑) | 0.9456 | 0.9582 | 0.8923 | 0.9689 | 0.9838 |
| Int. | RE (↑) | -2.5678 | -1.9812 | -3.4521 | -1.3456 | -0.5747 |
| Int. | CR (↓,%) | 13.45 | 12.23 | 17.56 | 11.12 | 9.08 |
| Int. | PE (↓, ms) | 4.9521 | 4.7214 | 4.6234 | 6.1234 | 4.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 (=88), reporting four checkpoint snapshots alongside a Frozen control that runs the same window with acquisition disabled (Table 3; other scenarios in Appendix § 11.§ 5). Across deployment, 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 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 | LLM Call Rate (%) | Compl. () | CR (%) () | |
| ep. 250 | 113 | 70.0 | 0.9885 | 7.05 |
| ep. 500 | 127 | 48.44 | 0.9920 | 6.11 |
| ep. 750 | 138 | 25.0 | 0.9942 | 5.83 |
| ep. 1000 (final) | 145 | 12.81 | 0.9956 | 5.67 |
| Frozen (1000-ep eval) | 88 | — | 0.9800 | 9.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 under -hash deduplication validates consolidation, the joint Compl. /CR trajectory validates rollout-based verification, and the 5.5 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 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 Variable | Micro Variable | Description |
| Environment | weather_type | Weather condition (clear/rain/fog/snow) |
| visibility_distance | Visibility range (m) | |
| road_friction | Road surface friction coefficient | |
| road_type | Scenario type (highway/merge/intersection/roundabout) | |
| time_of_day | Time period (day/night/dawn/dusk) | |
| speed_limit | Posted speed limit (km/h) | |
| Traffic | headway_distance | Distance to lead vehicle (m) |
| lead_speed | Lead vehicle speed (m/s) | |
| lead_rel_speed | Relative speed to lead vehicle (m/s) | |
| lead_ttc | Time-to-collision with lead vehicle (s) | |
| lead_thw | Time headway to lead vehicle (s) | |
| rear_distance | Distance to rear vehicle (m) | |
| rear_speed | Rear vehicle speed (m/s) | |
| rear_rel_speed | Relative speed to rear vehicle (m/s) | |
| rear_ttc | Time-to-collision with rear vehicle (s) | |
| left_front_distance | Distance to left-front vehicle (m) | |
| left_front_speed | Left-front vehicle speed (m/s) | |
| left_rear_distance | Distance to left-rear vehicle (m) | |
| left_rear_speed | Left-rear vehicle speed (m/s) | |
| right_front_distance | Distance to right-front vehicle (m) | |
| right_front_speed | Right-front vehicle speed (m/s) | |
| right_rear_distance | Distance to right-rear vehicle (m) | |
| right_rear_speed | Right-rear vehicle speed (m/s) | |
| lane_density_left | Left lane density (vehicles/100m) | |
| lane_density_right | Right lane density (vehicles/100m) | |
| available_gap_left | Available gap in left lane (m) | |
| available_gap_right | Available gap in right lane (m) | |
| cutin_risk | Cut-in risk indicator (0–1) | |
| Ego | ego_x | Ego vehicle longitudinal position (m) |
| ego_y | Ego vehicle lateral position (m) | |
| ego_vx | Ego vehicle longitudinal velocity (m/s) | |
| ego_vy | Ego vehicle lateral velocity (m/s) | |
| ego_speed | Ego vehicle total speed (m/s) | |
| ego_acceleration | Ego vehicle acceleration (m/s²) | |
| yaw_rate | Ego vehicle yaw rate (rad/s) | |
| jerk | Ego vehicle jerk (m/s³) | |
| lane_id | Current lane identifier | |
| lateral_offset | Lateral offset from lane center (m) | |
| Action | action_type | Discrete action (IDLE/FASTER/SLOWER/LANE_LEFT/LANE_RIGHT) |
| Outcome | risk_score | Collision probability (0–1) |
| comfort_score | Comfort metric (jerk-based) | |
| energy_consumption | Energy usage metric | |
| success_flag | Goal completion indicator (boolean) | |
| violation_flag | Rule 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 in Def. 3.1 encodes the admissible group-level edges:
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 THEN
AND-THEN: Conjunctive trigger requiring multiple conditions. Example: IF AND THEN
THRESHOLD: Numeric constraint with calibrated boundaries. Example: IF THEN
PRIORITY: Decision hierarchy for conflicting actions. Example: (yield takes priority)
MULTI-ACTION: Compound actions under one condition. Example: IF THEN AND
WEIGHTED-ACTION: Weighted action selection. Example: IF THEN
TEMPORAL-CHAIN: Temporal constraints between triggers. Example: IF THEN within
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 (), REINS falls back to dynamics-based verification. The top- 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 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 for each candidate edge . This is combined with the macro-group constraints (Eq. (10)) to form a unified prior:
where balances LLM confidence against structural constraints. Edges that violate the macro-group constraints carry indicator 0 and are reduced to , while semantically aligned edges are pushed toward 1.
Step 2: Prior-Guided Regression. For each target variable , we predict its value from the lagged values of other variables via ridge regression [13] with prior-adaptive penalties :
where is the regression coefficient for variable at lag , groups all lags for , is the base penalty, and controls penalty sharpness. High-prior edges () receive weak regularization and survive; low-prior edges are shrunk toward zero.
Step 3: Graph Construction. The parent set retains the top- variables ranked by aggregated coefficient magnitude . The learned edge set and weights are
Dynamics Function Loss. Given , each is implemented as a multi-head Transformer [39] and trained by mean squared error over its parent trajectory:
Optimizer, batch size, and convergence curves are reported in Appendix C.1.
Rule Compilation Details
Rule Structure Generation. For each dependency edge , the LLM generates a rule structure
where is the rule template (Def. 3.5), is a set of guard predicates with symbolic thresholds, is the recommended action (Def. 3.2), and is the confidence derived from edge weight . Prompt details are in Appendix A.5.
Threshold Calibration. Each predicate (Def. 3.4) requires a concrete threshold , calibrated from in three forms [25]:
where , are empirical mean and standard deviation of , is the -quantile, and is a fixed constant (e.g., speed limits). The comparison operator is selected to maximize safety separability between the two sides of the threshold under safety outcome (§ 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 , where is the template type, contains calibrated predicates with concrete thresholds and operators , is the recommended action, and is the confidence. Rule nodes connect to variable nodes via TRIGGERS (input variables) and AFFECTS (output variables) edges. This enables 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 , we identify active variables 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
returns up to rules ranked by confidence . A rule is retrieved if its trigger variables intersect with the active set and the dependency direction satisfies the macro-group constraints .
Action Scorer Architecture. The Transformer scorer [22] takes state encoding and rule embedding and emits relevance and action heads:
where predicts whether should influence the current decision, and predicts the action preference given . The combined rule-action score multiplies relevance, action preference, and rule confidence:
Scorer Training. The scorer is trained on expert trajectories with a joint relevance + action objective:
where is the ground-truth rule activation (Eq. (2)) and is the expert action.
Action Aggregation. The full noisy-OR action distribution corresponding to Eq. (5) is
where denotes the rules with recommended action and normalizes over . The formulation favors actions supported by multiple high-confidence rules.
Trajectory Verification. For the top- actions ranked by , we predict -step future states:
where applies each to predict from under . Each rollout produces a candidate trajectory , consistent with Def. 3.3. The planner selects , where 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 with the current state and active variables:
where conforms to the rule template (Def. 3.5) and uses only variables in and operators from the predicate grammar (Def. 3.4). Prompt details are in Appendix § 9.§ 5.
Safe-Action Selection. When online rule acquisition rejects and , the harness raises a human-takeover alert and executes the action that maximizes minimum lookahead time-to-collision under :
Memory-Update Collision Branch. Eq. (8)’s collision branch averages confidences instead of creating a duplicate node, so counts distinct rule structures rather than LLM-noise replicas. The hash is computed over the structural triple but excludes , so semantically identical proposals collide regardless of confidence noise. Collisions are common during early deployment when is small, then taper off as coverage saturates.
Self-Evolution Properties. Eq. (8) structurally enforces (memory monotonicity) and (no LLM parameter update). Under stationarity of the scene distribution, the per-state miss rate is non-increasing as accumulates coverage, since any state that triggered a miss and produced an accepted is now matched by a rule keyed on the variables active at . Since is invoked only on misses, its per-scene invocation rate decays monotonically with . 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.

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.

Figure 5. Rule extraction prompt from dependency structure.

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.
| Category | Setting |
| Simulation Environment | |
| Simulator | highway-env v1.8.2 |
| Scenarios | Highway, Merge, Roundabout, Intersection |
| Episode length | 100 steps (20s at 5 Hz) |
| Observation | 15 nearest vehicles |
| Action space | {IDLE, FASTER, SLOWER, LANE_LEFT, LANE_RIGHT} |
| Weather conditions | Clear, Rain, Fog, Snow |
| Real-world Datasets | |
| highD source | German Autobahn (drone) |
| highD recordings | 01, 02, 03, 04 |
| highD vehicles | 4,237 (578 lane-change events) |
| rounD source | German roundabouts |
| rounD recordings | 00, 01, 02 |
| rounD vehicles | 2,156 (423 yield/merge events) |
| Sampling rate | 25 Hz |
| World Dynamics Model | |
| Structure learning | Ridge regression + LLM prior |
| LLM prior weight | 0.6 |
| Penalty exponent | 2.0 |
| Base regularization | 0.1 |
| Lag length | 6 steps |
| Top- parents | 5 |
| Transformer layers | 2 |
| Attention heads | 4 |
| Optimizer | Adam |
| Learning rate | |
| Batch size | 64 |
| Training episodes | 50k |
| Rule Compilation (Offline) | |
| LLM backbone | GPT-4o (2024-08-06) |
| LLM temperature | 0.0 (deterministic) |
| Max output tokens | 4096 |
| Prompt tokens (avg.) | 1.2k per query |
| Total LLM calls | 50 (one-time offline) |
| Rule templates | 7 types |
| Neo4j version | 5.12 |
| Threshold calibration | Gaussian (), =1.5 |
| Confidence | 0.7 |
| Training & Evaluation | |
| Training data | 50k episodes |
| Test episodes | 1000 per scenario |
| Random seeds | 5 (0, 42, 123, 456, 789) |
| Training hardware | 4 A100 (40GB) |
| Training time | 8 hours |
| Planning & Deployment | |
| Retrieval count | 10 |
| Planning horizon | 5 steps |
| Rollout discount | 0.99 |
| Safety weight | 1.0 |
| Comfort weight | 0.1 |
| Progress weight | 0.5 |
| Inference hardware | RTX 3090 or above |
| GPU memory | 4 GB |
| Neo4j query latency | ms |
| Planning latency | 1.9–4.6 ms per decision |
| Real-time capability | 200–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:
where indicates whether rule is violated at time .
Collision Rate (CR) measures the fraction of episodes in which at least one collision occurs:
where is the number of test episodes. A lower CR indicates safer planning.
Risk-aware Efficiency (RE) balances task performance against safety:
where is the task reward, penalizes low TTC states, is the risk penalty weight, and is the TTC threshold.
Planning Efficiency (PE) measures average computation time per decision:
where (ms) is the wall-clock time for action selection.
Trajectory Objective . The trajectory-level objective used in dynamics-based verification is defined as:
where is the predicted time-to-collision, is the progress toward the goal, is the jerk, and is the safety threshold. The weights , , 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 and batch size 64. Each variable-specific dynamics function 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. | Metric | LLaDA | MPC | SymAgent | REINS |
| Hig. | ADE | 26.5 | 20.1 | 18.1 | 15.9 |
| FDE | 29.5 | 25.1 | 24.5 | 20.5 | |
| Reward | 14.7 | 21.6 | 23.1 | 26.3 | |
| Mer. | ADE | 17.6 | 13.3 | 12.7 | 9.9 |
| FDE | 21.8 | 20.0 | 18.5 | 15.2 | |
| Reward | 25.2 | 50.7 | 54.5 | 58.4 | |
| Rou. | ADE | 19.7 | 16.5 | 14.3 | 10.1 |
| FDE | 23.2 | 21.7 | 19.4 | 14.9 | |
| Reward | 12.3 | 22.9 | 23.6 | 27.8 | |
| Int. | ADE | 21.6 | 9.6 | 8.0 | 5.6 |
| FDE | 25.4 | 13.6 | 11.2 | 9.7 | |
| Reward | 35.3 | 54.2 | 56.8 | 60.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 and Planning Horizon
We analyze sensitivity to two runtime hyperparameters: rule retrieval count (the maximum number of rules returned per scene by the Cypher query) and planning horizon (the rollout depth used by trajectory verification). Both are evaluated on simulated (Highway, Roundabout) and real-world (highD, rounD) scenarios.
Rule Retrieval Count . tbl:9a reports results for varying . Small values () miss critical rules, increasing CR by 3.5–4.7 points; large values () introduce redundancy, raising PE by 60–71% at without safety gains. The optimal generalizes across domains, with real-world and roundabout scenarios showing higher sensitivity than structured highway settings.
Planning Horizon . tbl:9b reports results for varying . Short horizons () cause myopic decisions with 2.9–5.1 point CR increase; long horizons raise PE by 35–44% at and roughly
double it at , with marginal safety benefits. The optimal 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 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.
| Dataset | Scen. | Metric | |||||
| Sim. | Hig. | Compl. | 0.9934 | 0.9948 | 0.9956 | 0.9952 | 0.9947 |
| RE | -0.42 | 0.31 | 0.52 | 0.38 | 0.15 | ||
| CR (%) | 9.34 | 6.89 | 5.67 | 6.72 | 7.98 | ||
| PE (ms) | 2.21 | 2.35 | 2.50 | 2.68 | 2.89 | ||
| Rou. | Compl. | 0.9898 | 0.9915 | 0.9925 | 0.9918 | 0.9908 | |
| RE | -1.23 | -0.78 | -0.54 | -0.72 | -0.95 | ||
| CR (%) | 14.12 | 10.78 | 9.01 | 10.34 | 11.89 | ||
| PE (ms) | 3.18 | 3.41 | 3.62 | 3.89 | 4.21 | ||
| Real | highD | Compl. | 0.9845 | 0.9858 | 0.9867 | 0.9861 | 0.9852 |
| RE | -0.35 | 0.18 | 0.38 | 0.25 | 0.08 | ||
| CR (%) | 10.12 | 7.34 | 6.12 | 7.12 | 8.56 | ||
| PE (ms) | 2.38 | 2.52 | 2.62 | 2.87 | 3.12 | ||
| rounD | Compl. | 0.9823 | 0.9842 | 0.9856 | 0.9848 | 0.9834 | |
| RE | -1.12 | -0.65 | -0.41 | -0.58 | -0.82 | ||
| CR (%) | 15.23 | 11.34 | 9.45 | 10.78 | 12.45 | ||
| PE (ms) | 3.52 | 3.76 | 3.89 | 4.25 | 4.63 |
Table 7. Sensitivity to temporal lag length (default: 6).
When using small lag lengths (), 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 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 () 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, 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.
| Dataset | Scen. | Metric | Dataset | Scen. | Metric | |||||||||
| Sim. | Hig. | Compl. | 0.9712 | 0.9856 | 0.9956 | 0.9948 | 0.9951 | Sim. | Hig. | Compl. | 0.9948 | 0.9956 | 0.9953 | 0.9949 |
| RE | 0.18 | 0.41 | 0.52 | 0.35 | 0.21 | RE | -0.12 | 0.52 | 0.48 | 0.41 | ||||
| CR (%) | 9.21 | 7.08 | 5.67 | 6.02 | 6.48 | CR (%) | 8.56 | 5.67 | 5.91 | 5.78 | ||||
| PE (ms) | 1.82 | 2.13 | 2.50 | 3.21 | 4.15 | PE (ms) | 1.87 | 2.50 | 3.42 | 5.18 | ||||
| Rou. | Compl. | 0.9589 | 0.9778 | 0.9925 | 0.9912 | 0.9908 | Rou. | Compl. | 0.9908 | 0.9925 | 0.9919 | 0.9912 | ||
| RE | -1.12 | -0.78 | -0.54 | -0.72 | -0.89 | RE | -1.02 | -0.54 | -0.62 | -0.71 | ||||
| CR (%) | 13.34 | 10.45 | 9.01 | 9.62 | 10.28 | CR (%) | 12.78 | 9.01 | 9.62 | 9.38 | ||||
| PE (ms) | 2.67 | 3.12 | 3.62 | 4.56 | 5.78 | PE (ms) | 2.78 | 3.62 | 4.89 | 7.34 | ||||
| Real | highD | Compl. | 0.9689 | 0.9798 | 0.9867 | 0.9856 | 0.9852 | Real | highD | Compl. | 0.9856 | 0.9867 | 0.9862 | 0.9854 |
| RE | 0.05 | 0.25 | 0.38 | 0.22 | 0.09 | RE | -0.08 | 0.38 | 0.34 | 0.28 | ||||
| CR (%) | 10.01 | 7.63 | 6.12 | 6.58 | 7.08 | CR (%) | 9.78 | 6.12 | 6.48 | 6.32 | ||||
| PE (ms) | 2.05 | 2.38 | 2.62 | 3.52 | 4.48 | PE (ms) | 2.12 | 2.62 | 3.76 | 5.62 | ||||
| rounD | Compl. | 0.9534 | 0.9712 | 0.9856 | 0.9842 | 0.9836 | rounD | Compl. | 0.9838 | 0.9856 | 0.9848 | 0.9841 | ||
| RE | -1.02 | -0.65 | -0.41 | -0.58 | -0.76 | RE | -0.89 | -0.41 | -0.52 | -0.62 | ||||
| CR (%) | 14.12 | 11.08 | 9.45 | 10.02 | 10.75 | CR (%) | 14.56 | 9.45 | 10.06 | 9.78 | ||||
| PE (ms) | 2.98 | 3.48 | 3.89 | 5.02 | 6.28 | PE (ms) | 3.15 | 3.89 | 5.52 | 8.18 |
Table 9. (a) Rule retrieval count . (b) Planning horizon . Table 9: Sensitivity to retrieval count (left) and planning horizon (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 and report , LLM call rate, Compl., and CR at four deployment checkpoints (ep. 250, 500, 750, 1000), with a Frozen row showing the same 1000-episode window run with acquisition disabled; this row exposes and isolates the contribution of online rule writing from any aggregation effect of running more episodes. The per-scenario at ep. 1000 matches the post-deployment totals in Table 8.
| Template | Simulation Hig. | Simulation Mer. | Simulation Rou. | Simulation Int. | Real-world highD | Real-world rounD | Total |
| IF-THEN | 42 | 48 | 50 | 55 | 38 | 43 | 276 |
| AND-THEN | 38 | 45 | 47 | 52 | 32 | 37 | 251 |
| THRESHOLD | 32 | 35 | 36 | 40 | 30 | 32 | 205 |
| PRIORITY | 12 | 20 | 22 | 28 | 15 | 21 | 118 |
| MULTI-ACTION | 10 | 13 | 14 | 17 | 11 | 12 | 77 |
| WEIGHTED-ACTION | 6 | 8 | 9 | 11 | 7 | 10 | 51 |
| TEMPORAL-CHAIN | 5 | 6 | 7 | 7 | 5 | 15 | 45 |
| Total | 145 | 175 | 185 | 210 | 138 | 170 | 1,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, exhibits saturating growth: approximately 44% of the rule additions (counted from in the Frozen row to 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 and the residual call rate (highest on Intersection) but not the shape of the decay. Third, the Frozen 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 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 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 to monitor the lead vehicle and adjacent lanes, triggers R12 at when a safe gap appears, executes a lane change at , and accelerates via R15 at , producing a smooth action sequence (IDLEIDLERIGHTFASTER). Plan-R1 applies all 15 rules simultaneously, causing conflicting constraints and repeated deceleration (SLOWER) before a delayed maneuver.
Real-World highD. In the cut-in scenario, REINS detects lateral intrusion at via R05, performs preemptive deceleration at using R07, and maintains safe distance until (IDLESLOWERSLOWERIDLE). Plan-R1 responds later with emergency braking at 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 graph database retrieval ( 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 VariableRule, while blue edges represent RuleAction.
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.
| ID | Guard Condition | Action | Template |
| R01 | TTC | emergency brake | THRESHOLD |
| R02 | DEC to limit | THRESHOLD | |
| R03 | THW DHW | DEC / maintain gap | IF-THEN |
| R04 | TTC DHW | DEC (moderate) | AND-THEN |
| R05 | DEC (preemptive) | AND-THEN | |
| R06 | visibility | reduce speed 20% | THRESHOLD |
| R07 | cut-in | increase headway | IF-THEN |
| R08 | lane_end | prepare merge | TEMPORAL-CHAIN |
| R09 | at_yield traffic_present | yield / stop | PRIORITY |
| R10 | pedestrian | DEC / prepare stop | MULTI-ACTION |
| R11 | consider lane change | AND-THEN | |
| R12 | execute lane change | AND-THEN | |
| R13 | in_lane_change | abort lane change | AND-THEN |
| R14 | merge_complete DHW | DEC post-merge | AND-THEN |
| R15 | post_merge | ACC to flow | AND-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 : 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.
| Component | Driving (this paper) | Manipulation (sketch) | Transfer |
| Variable space and groups | 44 variables in Env, Traffic, Ego, Action, Outcome | joint angles and torques, end-effector pose, contact forces, object poses | redesign |
| Action space | 5 driving meta-actions | skill primitives (reach, grasp, lift, place, retreat) | redesign |
| Predicate grammar and thresholds | TTC and THW guards | force-margin, slip, and grasp-stability guards | grammar unchanged, thresholds recalibrated |
| Dynamics learning | LLM prior, group-weighted ridge, per-variable Transformer | same, retrained on domain data | unchanged |
| Verification | collision and violation terms in | contact-force and stability terms in | protocol unchanged |
| Indexed memory and retrieval | variable-keyed graph schema | same | unchanged |
| Acquisition loop | miss detection, proposal, verification, write-back | same | unchanged |
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.
| Condition | PDDL | DriReg | LLaDA |
| Observation space, action space, episodes | shared | shared | shared |
| GPT-4o backbone (2024-08-06), temperature 0 for rule generation | shared | shared | shared |
| 44-variable vocabulary (Appendix A.1) in rule-generation prompts | own vocabulary | own vocabulary | n/a (linguistic rules) |
| Threshold calibration | uncalibrated | uncalibrated | n/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 (%) | PDDL | PDDL matched | DriReg | DriReg matched | REINS |
| Highway | 25.93 | 21.37 | 21.76 | 18.92 | 5.67 |
| Intersection | 32.12 | 27.64 | 29.89 | 25.81 | 9.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.
| Method | Own rules | Common reference (REINS set) | ||
| Highway | Intersection | Highway | Intersection | |
| MPC | n/a | n/a | 0.8712 | 0.8423 |
| MCTS | n/a | n/a | 0.8831 | 0.8517 |
| DriveSpeak | n/a | n/a | 0.8246 | 0.7912 |
| LLaDA | n/a | n/a | 0.8412 | 0.8104 |
| PDDL | 0.9123 | 0.8789 | 0.8867 | 0.8621 |
| DriReg | 0.9452 | 0.9153 | 0.9083 | 0.8874 |
| SymAgent | 0.9561 | 0.9274 | 0.9312 | 0.9067 |
| Plan-R1 | 0.9717 | 0.9553 | 0.9498 | 0.9231 |
| REINS | 0.9956 | 0.9838 | 0.9956 | 0.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 . 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-4o | Threshold shift after calibration | Compl. | CR (%) |
| GPT-4o (paper) | n/a | n/a | 0.9956 | 5.67 |
| Claude Sonnet 4.5 | 87.3% | 3.2% | 0.9948 | 5.89 |
| Qwen2.5-72B-Instruct | 81.6% | 3.8% | 0.9931 | 6.24 |
| Three prompt paraphrases, GPT-4o | 91.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 Highway | no noise | 2.5% noise | 5% noise | 10% noise | 5% frame drops |
| REINS | 5.67 | 5.92 | 6.51 | 8.14 | 6.88 |
| Plan-R1 | 12.83 | 13.71 | 15.42 | 19.87 | 16.50 |
Table 17. Collision rate under -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 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.
| Scenario | Checkpoint | LLM Call (%) | Compl. (↑) | CR (%) (↓) | |
| Merge | ep. 250 | 136 | 71.36 | 0.9858 | 8.20 |
| ep. 500 | 153 | 49.12 | 0.9893 | 7.35 | |
| ep. 750 | 167 | 26.48 | 0.9912 | 7.05 | |
| ep. 1000 (final) | 175 | 13.92 | 0.9924 | 6.86 | |
| Frozen (1000-ep eval) | 105 | — | 0.9770 | 10.65 | |
| Roundabout | ep. 250 | 144 | 73.84 | 0.9852 | 10.55 |
| ep. 500 | 162 | 52.20 | 0.9888 | 9.85 | |
| ep. 750 | 176 | 28.36 | 0.9910 | 9.40 | |
| ep. 1000 (final) | 185 | 15.24 | 0.9925 | 9.01 | |
| Frozen (1000-ep eval) | 112 | — | 0.9770 | 13.40 | |
| Intersection | ep. 250 | 164 | 78.52 | 0.9742 | 10.85 |
| ep. 500 | 184 | 57.64 | 0.9789 | 9.95 | |
| ep. 750 | 200 | 33.08 | 0.9817 | 9.45 | |
| ep. 1000 (final) | 210 | 18.76 | 0.9838 | 9.08 | |
| Frozen (1000-ep eval) | 127 | — | 0.9620 | 13.95 | |
| highD | ep. 250 | 107 | 68.24 | 0.9803 | 7.45 |
| ep. 500 | 121 | 47.56 | 0.9838 | 6.65 | |
| ep. 750 | 131 | 24.12 | 0.9856 | 6.32 | |
| ep. 1000 (final) | 138 | 12.36 | 0.9867 | 6.12 | |
| Frozen (1000-ep eval) | 84 | — | 0.9712 | 9.95 | |
| rounD | ep. 250 | 132 | 74.68 | 0.9785 | 10.95 |
| ep. 500 | 149 | 53.40 | 0.9821 | 10.20 | |
| ep. 750 | 162 | 29.72 | 0.9842 | 9.78 | |
| ep. 1000 (final) | 170 | 16.08 | 0.9856 | 9.45 | |
| Frozen (1000-ep eval) | 103 | — | 0.9692 | 13.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 .
| Scenario | Checkpoint | LLM Call (%) | Compl. | CR (%) | PE (ms) | |
| Setting A: from highD and rounD, deployed on highway-env | ||||||
| Highway | ep. 250 | 265 | 86.2 | 0.9612 | 11.84 | 2.71 |
| Highway | ep. 1000 | 349 | 14.9 | 0.9914 | 6.21 | 2.54 |
| Highway | ep. 1000, acquisition frozen | — | — | — | 11.20 | — |
| Highway | native, ep. 1000 | 145 | 12.81 | 0.9956 | 5.67 | 2.50 |
| Intersection | ep. 250 | 287 | 91.3 | 0.9487 | 15.62 | 4.87 |
| Intersection | ep. 1000 | 391 | 17.2 | 0.9782 | 10.13 | 4.66 |
| Intersection | native, ep. 1000 | 210 | 12.81 | 0.9838 | 9.08 | 4.58 |
| Setting B: from the four simulated scenarios, deployed on highD and rounD | ||||||
| highD | ep. 250 | 471 | 71.4 | 0.9702 | 9.87 | 2.79 |
| highD | ep. 1000 | 508 | 13.6 | 0.9838 | 6.79 | 2.68 |
| highD | native, ep. 1000 | 138 | 12.81 | 0.9867 | 6.12 | 2.62 |
| rounD | ep. 250 | 478 | 79.8 | 0.9645 | 14.21 | 4.12 |
| rounD | ep. 1000 | 517 | 15.1 | 0.9821 | 10.24 | 3.97 |
| rounD | native, ep. 1000 | 170 | 12.81 | 0.9856 | 9.45 | 3.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 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.
| Stage | Mean | p95 | Deployment scheduling |
| Fallback action for the current step | 2.6 ms | 3.9 ms | control path, within budget |
| Prompt assembly and state serialization | 0.9 ms | 1.4 ms | background |
| LLM rule proposal (GPT-4o API) | 1.58 s | 2.94 s | background |
| Parsing and schema validation | 2.1 ms | 3.0 ms | background |
| Threshold calibration on the sliding window | 1.3 ms | 1.9 ms | background |
| Rollout verification at | 1.6 ms | 2.2 ms | background |
| Neo4j insert and index update | 4.7 ms | 6.8 ms | background |
| Full cycle, miss to usable rule | 1.59 s | 2.96 s | background |
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.

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 rules regardless of memory size, so noisy-OR aggregation (Eq. (5)) and the arbitration of Appendix § 9.§ 3 cost . 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 size | 1,023 (paper) | 10,000 | 50,000 | 100,000 |
| Cypher retrieval (ms) | 0.41 | 0.55 | 0.68 | 0.79 |
| End-to-end PE (ms) | 2.50 | 2.64 | 2.77 | 2.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]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]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]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]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]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]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]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]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]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]Douglas Gettman and Larry Head. Surrogate safety measures from traffic simulation models. Transportation Research Record, 1840(1):104–115, 2003.DOI
- [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]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]Arthur E Hoerl and Robert W Kennard. Ridge regression: Biased estimation for nonorthogonal problems. Technometrics, 12(1):55–67, 1970.
- [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]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]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]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]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]Edouard Leurent. An environment for autonomous driving decision-making. https://github.com/eleurent/highway-env, 2018.DOI
- [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]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]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]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]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]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]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]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]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]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]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]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]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]Jonas Peters, Dominik Janzing, and Bernhard Schölkopf. Elements of Causal Inference: Foundations and Learning Algorithms. The MIT Press, 2017.
- [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]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]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]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]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]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]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]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]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]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]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]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]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]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]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



