SignalClaw: LLM-Guided Evolutionary Synthesis of Interpretable Traffic Signal Control Skills

Da Lei; Feng Xiao; Lu Li; Yuzhan Liu

cs.AIApr 7, 2026

SignalClaw: LLM-Guided Evolutionary Synthesis of Interpretable Traffic Signal Control Skills

Authors: Da Lei, Feng Xiao, Lu Li, Yuzhan Liu

Organizations: Business School, Sichuan University, Chengdu, China

Abstract

Traffic signal control TSC requires strategies that are both effective and interpretable for deployment, yet reinforcement learning produces opaque neural policies while program synthesis depends on restrictive domain-specific languages. We present SIGNALCLAW, a framework that uses large language models LLMs as evolutionary skill generators to synthesize and refine interpretable control skills for adaptive TSC. Each skill includes rationale, selection guidance, and executable code, making policies human-inspectable and self-documenting. At each generation, evolution signals from simulation metrics such as queue percentiles, delay trends, and stagnation are translated into natural language feedback to guide improvement. SignalClaw also introduces event-driven compositional evolution: an event detector identifies emergency vehicles, transit priority, incidents, and congestion via TraCI, and a priority dispatcher selects specialized skills. Each skill is evolved independently, and a priority chain enables runtime composition without retraining. We evaluate SignalClaw on routine and event-injected SUMO scenarios against four baselines. On routine scenarios, it achieves average delay of 7.8 to 9.2 seconds, within 3 to 10 percent of the best method, with low variance across random seeds. Under event scenarios, it yields the lowest emergency delay 11.2 to 18.5 seconds versus 42.3 to 72.3 for MaxPressure and 78.5 to 95.3 for DQN, and the lowest transit person delay 9.8 to 11.5 seconds versus 38.7 to 45.2 for MaxPressure. In mixed events, the dispatcher composes skills effectively while maintaining stable overall delay. The evolved skills progress from simple linear rules to conditional strategies with multi-feature interactions, while remaining fully interpretable and directly modifiable by traffic engineers.

Figures & tables

Method	Prog.	LLM	Signal	Event	Multi-mode	Audit	Strategy Form
Fixed-timing	✓	✗	✗	✗	✗	✗	Pre-set phase durations
MaxPressure ( Varaiya, 2013 )	✓	✗	✗	✗	✗	✗	Pressure-based rule
PI-Light ( Gu et al., 2024 )	✓	✗	✗	✗	✗	✗	DSL expression (MCTS)
SymLight ( Liao et al., 2025 )	✓	✗	✗	✗	✗	✗	Symbolic expression
LLMLight ( Lai et al., 2023 )	✗	✓	✗	✗	✗	✗	LLM direct decision
Heuristic-policy evolution ( Wang et al., 2025 )	✓	✓	✗	✗	✗	✗	LLM-guided heuristic search

Table 1: Comparison of SignalClaw with related TSC approaches. Prog. : strategies are interpretable programs. LLM : uses LLM for strategy synthesis. Signal : uses structured traffic feedback. Event : handles traffic events (EVP/TSP/incident). Multi-mode : supports multiple control modes. Audit : full evolution audit trail.

Panel of Figure 1 — Figure 1: Overview of the SignalClaw framework. Each generation follows a Generate–Test–Evolve–Solidify loop. The LLM synthesizes candidate skills —structured artifacts comprising a strategy description, selection guidance, and executable code—conditioned on the current elite skill, performance metrics, and natural-language evolution signals extracted from traffic simulation. Signals such as high_queue or force_innovation are translated into targeted natural-language directions that steer the LLM toward semantically meaningful skill modifications.

Mode	Decision Point	Output	Granularity
Phase Selection	Every step	Phase score	Per-step
Phase Extension	End of min green	Extension (sec)	Per-phase
Cycle Planning	Cycle start	Duration per phase	Per-cycle

Table 2: Control modes supported by SignalClaw. Each mode defines a different level of temporal granularity for signal control.

Panel of Figure 2 — Figure 2: Overview of the twelve SUMO evaluation scenarios. (a) Routine scenarios use a 4 $\times$ 4 arterial grid with 16 signalized intersections; training (T1–T3) varies demand patterns while validation (V1–V3) perturbs demand by $\pm$ 15%. (b) Emergency scenarios inject ambulances at regular intervals to test priority preemption. (c) Transit scenarios introduce bus lines requiring transit signal priority. (d) Incident and mixed scenarios simulate vehicle breakdowns and combined events to test compositional skill dispatch through the priority chain.

Skill	Scenarios	Initial	Best	Gen	Improv. (%)
Normal	T1+T2+T3	55.20	60.50	12	9.6
Emergency	E1+E2	3.15	3.92	22	24.4
Transit	B1+B2	2.88	3.76	8	30.6
Incident	I1	2.65	3.28	18	23.8

Table 3: Evolution results across routine and event scenarios. Both normal fitness ( Equation 2 ) and event fitness ( Equation 5 ) are shifted by scenario-dependent constants

C

so that all values are positive (higher is better). The two objectives differ in composition and scale. Absolute values are not cross-comparable between normal and event rows; only the within-row improvement percentage is meaningful. All evolved with GPT-5.4,

M=8

, 30 generations. The mixed scenario M1 is not listed because it uses the dispatcher to compose independently evolved emergency and incident skills (zero-shot composability test, Section 4.3 ); no dedicated mixed skill is evolved.

		FixedTime		MaxPressure		PI-Light		DQN		SignalClaw
Scenario	Type	mean	std	mean	std	mean	std	mean	std	mean	std
T1	Train	47.3	1.5	13.8	0.9	8.5	0.7	7.9	1.2	8.7	0.6
T2	Train	43.6	1.3	12.5	0.8	8.1	0.6	8.4	1.1	7.8	0.4
T3	Train	52.1	1.8	14.2	1.0	7.9	0.8	8.3	1.3	8.4	0.7
V1	Valid	49.8	1.6	14.5	1.0	9.3	0.8	8.7	1.4	9.1	0.6
V2	Valid	46.2	1.4	13.9	0.9	9.6	0.7	8.5	1.2	9.2	0.8

Table 4: Routine scenario comparison (mean

\pm

std, 5 seeds). Avg Delay is per-vehicle accumulated waiting time (seconds). T1–T3 are training scenarios; V1–V3 are held-out validation scenarios with

\pm

15% demand perturbation. Best per row in bold ; worst adaptive method underlined .

Figure 3: Evolution curves across 30 generations. (a) Normal skill evolved on T1–T3: rapid improvement in the first 12 generations followed by a plateau (9.6% total improvement). (b) Event dispatcher-context evolution: transit skill achieves the fastest improvement (30.6% by generation 8), while emergency and incident skills show steady gains over more generations.

Scenario	Method	Avg Delay $\downarrow$		Emg Delay $\downarrow$		Person-Delay $\downarrow$		Queue $\downarrow$
		mean	std	mean	std	mean	std	mean	std
E1	FixedTime	48.5	1.6	385.2	48.7	—	—	32.4	1.2
	MaxPressure	14.2	1.0	42.3	6.8	—	—	8.9	0.7
	PI-Light	9.8	0.8	55.2	9.1	—	—	5.7	0.5
	DQN	11.3	2.1	78.5	32.4	—	—	6.8	1.5
	SignalClaw	11.5	0.7	14.7	2.8	—	—	6.9	0.5

Table 5: End-to-end system comparison across event scenarios (mean

\pm

std, 5 seeds). Best Avg Delay per scenario in bold ; best event-specific delay (Emg/Bus) in bold . SignalClaw uses GPT-5.4-evolved event-specific skills with priority dispatch; baselines are trained/searched on T1–T3 only (zero-shot transfer to event scenarios). Avg Delay measures per-vehicle accumulated waiting time (seconds). Person-Delay in B1/B2 is per-person waiting time weighted by vehicle occupancy (bus

\times

30, car

\times

1.5) ( Christofa et al., 2013 ) , reflecting the societal cost of delaying high-occupancy vehicles; it aggregates all vehicle types, not buses alone. B1/B2 scenarios include dedicated bus lanes to distinguish from emergency scenarios.

Comparison	E1 ( $p$ , $d$ )	E2 ( $p$ , $d$ )	B1 ( $p$ , $d$ )	B2 ( $p$ , $d$ )	M1 ( $p$ , $d$ )
vs. MaxPressure	$<$ 0.001, 5.3 ✓	$<$ 0.001, 14.0 ✓	$<$ 0.001, 7.6 ✓	$<$ 0.001, 7.2 ✓	$<$ 0.001, 6.0 ✓
vs. PI-Light	$<$ 0.001, 6.0 ✓	$<$ 0.001, 12.1 ✓	$<$ 0.001, 7.3 ✓	$<$ 0.001, 7.1 ✓	$<$ 0.001, 6.2 ✓
vs. DQN	0.011, 2.8 ✓	0.008, 3.1 ✓	0.012, 2.7 ✓	0.013, 2.7 ✓	0.015, 2.6 ✓

Table 6: Statistical significance (Welch’s

t

-test,

\alpha=0.05

n=5

seeds per method) of SignalClaw vs. baselines on event-specific delay.

\checkmark

: significant at

p<0.05

. Cohen’s

d

: effect size (large if

d>0.8

Method	E1		E2
Method	Emerg. Delay	Avg. Delay	Emerg. Delay	Avg. Delay
Handcrafted Preemption	0.8 s	14.8 s	0.5 s	17.2 s
SignalClaw (evolved)	14.7 s	11.5 s	11.2 s	12.3 s

Table 7: Handcrafted Preemption vs. SignalClaw on emergency scenarios (mean over 5 SUMO random seeds; same seeds as Table 5 ). Both use the same event detector, priority dispatcher, and event-context variables; the only difference is evolved skills vs. deterministic preemption rules. Handcrafted preemption minimizes emergency delay but substantially degrades normal vehicle delay.

Variant	Improv. (%)
Signal ablation
Full signals (skill)	47.3
No signals (skill)	26.8
Random direction (skill)	21.5
Representation ablation
Full signals (code-only)	39.9

Table 8: Ablation: effect of evolution signals and skill representation on T1 (100 generations, GPT-5.4). Improvement is measured as percentage increase in fitness relative to the seed skill (higher is better). Full signal-driven skill evolution achieves the strongest improvement.

$\star$ Best-ever skill on T1.
Gen	Strategy Description	Executable Code ( inlane )
0	Baseline: accumulate waiting vehicles.	value[0] += waiting_vehicle
1	Nonlinear queue weighting with distance penalty for spread-out queues.	value[0] += waiting*1.5 + min(3, waiting)dist
3	Self-reinforcing queue urgency: longer queues get disproportionate priority.	value[0] += waiting * (1 + min(3, waiting))
19 $\star$	Saturation-aware branching: heavy queues ( $>$ 5) use distance-adjusted scoring; light queues get linear boost.	if waiting > 5: value[0] += waiting * (max(1, dist) ...) elif waiting > 0: value[0] += waiting * 2
50	Ratio-based saturation: score by excess waiting fraction relative to total vehicles.	if waiting > vehicles//3: value[0] += (waiting - vehicles//3)**2

Table 9: Evolution of skills on T1. Each skill comprises a strategy description (natural language) and executable code. Skills progress from simple linear rules to conditional logic with multi-feature interactions. Generation 19 achieves the best fitness.

Method	LOC	AST Nodes	Readable?	Modifiable?
DQN	N/A	$>$ 16,000 params	✗	✗
PI-Light	1	3–7	✓	✓
MaxPressure	1	5	✓	✓
SignalClaw (gen 0)	1	3	✓	✓
SignalClaw (gen 19)	4–6	15–20	✓	✓
SignalClaw (final)	3–5	12–18	✓	✓

Table 10: Interpretability comparison across methods. LOC: lines of code. AST: abstract syntax tree nodes. SignalClaw skills are compact, self-documenting, and modifiable by domain experts.

Skill Type	LLM Calls	SUMO Runs	Wall-clock	Skill LOC
Normal (T1+T2+T3, 30 gen)	$\sim$ 240	$\sim$ 720	$\sim$ 8 h	4–6
Emergency (E1+E2, 30 gen)	$\sim$ 240	$\sim$ 480	$\sim$ 6 h	3–5
Transit (B1+B2, 30 gen)	$\sim$ 240	$\sim$ 480	$\sim$ 6 h	2–4
Incident (I1, 30 gen)	$\sim$ 240	$\sim$ 240	$\sim$ 4 h	3–4

Table 11: Search cost per skill type. LLM calls include retries. SUMO runs count multi-scenario evaluations. All experiments ran on a single NVIDIA DGX Spark.

Appendix figures & tables7 assets

Supplementary material from the paper’s appendix.

Appendix

Abstract Name	Lane-Indexed Alias	Source
Inlane features (per lane-link)
num_vehicle	inlane_2_num_vehicle	traci.lane.getLastStepVehicleNumber
num_waiting_vehicle	inlane_2_num_waiting_vehicle	traci.lane.getLastStepHaltingNumber
vehicle_dist	inlane_2_vehicle_dist	Mean inter-vehicle distance
Outlane features (per lane-link)
num_vehicle	outlane_2_num_vehicle	traci.lane.getLastStepVehicleNumber

Appendix

Table 12: Sandbox variable mapping. Abstract names are defined in the system prompt whitelist; lane-indexed names are aliases generated by the LLM. Both resolve to the same runtime value. Event-context variables (bottom block) have no lane prefix—they are global per intersection.

Component	Content
Description	Saturation-aware phase scoring with distance-adjusted urgency. Prioritizes phases with heavy queue buildup ( $>$ 5 vehicles) using a distance-modulated scoring function, while maintaining linear responsiveness for moderate queues.
Guidance	(1) When waiting vehicles exceed 5 (saturation threshold), apply distance-adjusted weighting to account for spatial queue density. (2) For moderate queues (1–5 vehicles), use simple doubling to maintain responsiveness. (3) Ignore phases with zero waiting vehicles to avoid noise.
Inlane Code	if inlane_2_num_waiting_vehicle > 5: value[0] += inlane_2_num_waiting_vehicle * (max(1, inlane_2_vehicle_dist) - inlane_2_vehicle_dist % 3) + inlane_2_num_vehicle // 4 elif inlane_2_num_waiting_vehicle > 0: value[0] += inlane_2_num_waiting_vehicle * 2
Outlane Code	value[0] += min(10, outlane_2_num_vehicle) * max(0, outlane_2_vehicle_dist - 3)

Appendix

Table 13: Complete skill representation for the best T1 skill (generation 19). The three components—description, guidance, and executable code—form a self-documenting control artifact.

Signal	Direction
force_innovation	Multiple stagnant generations. Try completely different structure.
high_queue	Queue exceeds P75. Focus on queue management.
low_throughput	Throughput below P25. Optimize flow efficiency.
high_delay	Delay exceeds P75. Reduce vehicle waiting time.
performance_gain	Performance improved. Continue optimizing current direction.
performance_decline	Performance declined. Try different strategy approach.

Appendix

Table 14: Evolution signal to natural-language direction mapping.

Scenario	Event Type	Configuration
E1	Emergency	Ambulance injected every 300 s (12 total), random O-D routes. Vehicle class: emergency , speed: 20 m/s.
E2	Emergency	Ambulance injected every 120 s (30 total), higher frequency stress test.
B1	Transit	2 bus lines, headway 180 s (40 buses total). Bus stops at every intersection. Vehicle class: bus .
B2	Transit	4 bus lines, headway 120 s (120 buses total). Dense bus operation.
I1	Incident	Single vehicle breakdown at $t=600$ s on a major east-west arterial link. Blocks one lane for 300 s (until $t=900$ s).
M1	Mixed	Emergency (every 300 s) + incident at $t=600$ s. Tests compositional dispatch of emergency (P0) and incident (P1) skills.

Appendix

Table 15: Event-injected scenario configurations. All scenarios use the same 4

\times

4 arterial grid with 16 intersections and 3600 s simulation duration.

Configuration	Runs	Wall-clock Time
Normal skill (T1+T2+T3, 30 gen)	30 gen $\times$ 8 pop $\times$ 3 scen	$\sim$ 8 hours
Event skills (3 types, 30 gen each)	3 $\times$ 30 gen $\times$ 8 pop	$\sim$ 16 hours
Ablation (T1, 100 gen, 3 variants)	3 $\times$ 100 gen $\times$ 8 pop	$\sim$ 30 hours
Baseline evaluation (5 methods $\times$ 7 scen $\times$ 5 seeds)	175 runs	$\sim$ 10 hours
DQN training (T1, 200 episodes)	200 episodes	$\sim$ 4 hours
PI-Light MCTS (T1, 16 iterations)	16 iterations	$\sim$ 2 hours

Appendix

Table 16: Approximate runtime per configuration.

Scenario	Strategy Description	Executable Code
T1 (gen 19)	Saturation-aware branching with distance-adjusted urgency for heavy queues.	inlane : if waiting > 5: value[0] += waiting * (max(1, dist) - dist % 3) + vehicles // 4 elif waiting > 0: value[0] += waiting * 2 outlane : value[0] += min(10, vehicles) * max(0, dist - 3)
T2 (gen 59)	Distance-weighted queue scoring with vehicle density bonus.	inlane : value[0] += waiting * max(1, dist) + vehicles // 5
T3 (gen 79)	Ratio-based saturation detection: penalize excess waiting fraction.	inlane : if waiting > vehicles // 3: value[0] += (waiting - vehicles // 3) ** 2

Appendix

Table 17: Best evolved skills per routine scenario (full representation). Important: T1 is from the main 30-generation evolution used in all reported results ( Tables 4 and 5 ). T2 and T3 are from separate extended 100-generation runs (same GPT-5.4 backbone, same setup as the ablation in Section 4.9 ) included solely to illustrate the diversity of evolved strategies across scenarios— these extended-run skills are not used in any evaluation table .

$\dagger$ Hand-tuned rule, not evolved.
Event Type	Strategy Description	Executable Code
Emergency	Distance-aware preemption: grant maximum priority to the phase serving the emergency vehicle’s approach, scaled inversely by distance.	inlane : if emergency_distance > 0: if emergency_phase == index: value[0] += max(0, 200 - emergency_distance) * 10 else: value[0] += waiting * 2 else: value[0] += waiting * 3 outlane : value[0] -= num_vehicle * 0.3
Transit (gen 9)	Bus-priority scoring with amplified waiting weight and density compensation within dispatcher context.	inlane : value[0] += waiting * 4 + vehicles / max(1, dist) outlane : value[0] -= (vehicles / max(1, dist)) * 2
Incident	Incident-aware diversion: prioritize moving vehicles over queued vehicles when lanes are blocked by an incident.	inlane : if incident_blocked > 0: value[0] += max(0, vehicles - waiting) * 5 else: value[0] += waiting * 3 outlane : value[0] -= vehicles * 0.5
Congestion $\dagger$	Nonlinear saturation response with severity-scaled bonus at high congestion levels.	inlane : value[0] += waiting ** 2 if congestion_level > 1: value[0] += waiting * congestion_level * 2 outlane : value[0] += dist * 0.5

Appendix

Table 18: Event-specialized skills used in event evaluation. Emergency, transit, and incident skills are evolved via dispatcher-context evolution ( Section 4.4 ) with 30 generations of GPT-5.4. Emergency and incident skills converge to designs structurally similar to the initial seed, reflecting the narrow optimization landscape for rare-event response; the transit skill exhibits more substantial structural change (best at generation 9). The congestion skill is a hand-tuned rule (not evolved) since no dedicated congestion scenario is included in the evaluation. Event-context variables (e.g., emergency_distance ) are injected into the sandbox alongside standard traffic features.

Traffic Signal Control

Traffic signal control studies how to set intersection phases and green times to reduce congestion while balancing safety, emissions, and priority needs.

See all 39 papers

EvoSignal: LLM-Guided Evolutionary Design of Modular Traffic Signal Control Programs
Oct 7, 2026Leizhen Wang, Peibo Duan, Zhenlin Qin +5Traffic Signal Control Automated Heuristic Design
Monash University · KTH Royal Institute of Technology · Chinese Academy of Sciences +2
ProcessLight: Process Supervision for Large Language Model Based Traffic Signal Control
Sep 19, 2026Huaitao Zhao, Tianlong Zhou, Weijie Wang +2Language Model-Based Control Traffic Signal Control
School of Computer Science and Technology, Tongji University, Shanghai, China
CuraLight: Debate-Guided Data Curation for LLM-Centered Traffic Signal Control
Apr 7, 2026Qing Guo, Xinhang Li, Junyu Chen +4Traffic Signal Control Language Model-Based Control
School of Artificial Intelligence, Beijing University of Posts and Telecommunications, Beijing, China · Beijing Big Data Center, Beijing, China

Oct 7, 2026J/K move · Enter open · S save

EvoSignal: LLM-Guided Evolutionary Design of Modular Traffic Signal Control Programs

Leizhen Wang, Peibo Duan, Zhenlin Qin, Yancheng Ling+4

Monash University · KTH Royal Institute of Technology · Chinese Academy of Sciences+2

Traffic Signal Control Automated Heuristic Design LLM-Based Program Synthesis Program Synthesis Evolutionary Optimization

Open paper AskPDF arXiv

Effective traffic signal control (TSC) requires policies that respond to changing traffic demand and network conditions while meeting different control objectives. However, adapting existing strategies often involves repeated manual design and adjustment, making it difficult to systematically explore better control rules for a target network. Large language models (LLMs) can automate this process, but directly using them to select signal phases leaves decision rules embedded in black-box models and incurs recurring inference costs and latency. This paper formulates TSC as a modular program design problem and proposes EvoSignal, an LLM-guided evolutionary framework using traffic knowledge and performance feedback. The modular representation separates traffic feature extraction, local phase prioritization, and optional network-based priority adjustment. Starting from several established strategies, EvoSignal improves programs through feedback on congestion and signal operation, retaining strategies with different performance trade-offs. The resulting programs operate without online LLM inference. Simulation experiments across five scenarios on two real-world road networks show that the selected default EvoSignal program reduces waiting time by 16.8--49.2% relative to the lowest waiting time achieved by the 20 conventional, reinforcement learning-based, and LLM-based baselines in each scenario. A program prioritizing travel time and queue length outperforms all 20 baselines on all three metrics in the search scenario and remains among the top three on each metric when transferred unchanged to the other four scenarios. These findings support automated design of inspectable control programs that transfer across the evaluated road networks and traffic demands. Code is available at https://github.com/georgewanglz2019/EvoSignal.

Abstract

Traffic Signal Control

Explore similar work

EvoSignal: LLM-Guided Evolutionary Design of Modular Traffic Signal Control Programs

ProcessLight: Process Supervision for Large Language Model Based Traffic Signal Control

CuraLight: Debate-Guided Data Curation for LLM-Centered Traffic Signal Control