EvolveSignal: A Large Language Model Powered Coding Agent for Discovering Traffic Signal Control Algorithms (2509.03335v2)

Abstract: In traffic engineering, the fixed-time traffic signal control remains widely used for its low cost, stability, and interpretability. However, its design depends on hand-crafted formulas (e.g., Webster) and manual re-timing by engineers to adapt to demand changes, which is labor-intensive and often yields suboptimal results under heterogeneous or congested conditions. This paper introduces the EvolveSignal, a LLMs powered coding agent to automatically discover new traffic signal control algorithms. We formulate the problem as program synthesis, where candidate algorithms are represented as Python functions with fixed input-output structures, and iteratively optimized through external evaluations (e.g., a traffic simulator) and evolutionary search. Experiments on a signalized intersection demonstrate that the discovered algorithms outperform Webster's baseline, reducing average delay by 20.1% and average stops by 47.1%. Beyond performance, ablation and incremental analyses reveal that EvolveSignal modifications-such as adjusting cycle length bounds, incorporating right-turn demand, and rescaling green allocations-can offer practically meaningful insights for traffic engineers. This work opens a new research direction by leveraging AI for algorithm design in traffic signal control, bridging program synthesis with transportation engineering.

• The paper introduces an LLM-powered program synthesis framework, EvolveSignal, that evolves traffic signal control algorithms using evolutionary search and LLM-guided modifications.
• It achieves significant performance gains by reducing average delay by 20.1% and stops by 47.1% over the traditional Webster's method.
• The framework balances interpretability and diversity, leveraging ablation studies to validate synergistic modifications like cycle length bound and right-turn inclusion.

EvolveSignal: LLM-Powered Program Synthesis for Fixed-Time Traffic Signal Control

Introduction and Motivation

The paper introduces EvolveSignal, a framework leveraging LLMs as coding agents to automate the discovery of fixed-time traffic signal control algorithms. The motivation stems from the limitations of traditional fixed-time methods, such as Webster's formula, which require manual tuning and often yield suboptimal results under heterogeneous or congested conditions. While adaptive traffic signal control (ATSC) methods based on RL and LLMs have demonstrated high performance, their deployment is constrained by infrastructure requirements and operational costs. EvolveSignal addresses these challenges by formulating fixed-time control as a program synthesis problem, enabling the automatic generation and optimization of interpretable, executable algorithms using LLM-guided evolutionary search.

Problem Formulation

The optimization task is defined as learning a function $f_\theta: X \rightarrow Y$, where $X$ comprises intersection-specific features (e.g., traffic volumes, geometry, phase configuration) and $Y$ denotes fixed-time signal parameters (cycle length, green splits). Unlike parameter tuning, the approach seeks to discover new algorithmic logic by evolving Python functions that encode the control strategy. The objective is to maximize expected performance over a distribution of traffic scenarios, with evaluation metrics such as average delay and stops.

Figure 1: The problem definition in Python, illustrating the mapping from intersection features to signal timing plans.

EvolveSignal Framework Architecture

EvolveSignal consists of four core modules: Program Database, Prompt Sampler, LLMs Ensemble, and Evaluators Pool. The process begins with an initial program (Webster's implementation), which is iteratively modified by LLMs based on performance feedback from traffic simulation. The evolutionary loop employs MAP-Elites for diversity maintenance and performance tracking, while prompt templates guide LLMs to propose code-level modifications. Candidate programs are evaluated in SUMO, and the best-performing algorithms are retained.

Figure 2: The EvolveSignal framework, detailing the evolutionary loop and integration of LLMs for program synthesis.

Experimental Setup

Experiments were conducted on a simulated four-leg intersection in SUMO, with heavy traffic scenarios designed to stress-test algorithmic adaptability. The intersection features four fixed phases and multiple lane types, including shared through–right lanes. The initial program is Webster's method, and the LLMs Ensemble samples from DeepSeek-v3, DeepSeek-r1, OpenAI-o4-mini-high, and OpenAI-o3. Performance is measured by average delay ($\bar{d}$) and average stops ($\bar{s}$), normalized into a combined score $S_c$.

Figure 3: Simulated isolated intersection in SUMO used for evaluation.

Evolutionary Results and Key Modifications

The evolutionary process yielded a discovered program that significantly outperformed the initial baseline. After 300 iterations, the best program reduced average delay by 20.1% and stops by 47.1%, with a 21.5% improvement in the combined score. The evolution path demonstrates consistent performance gains, with occasional plateaus and declines indicative of exploration dynamics.

Figure 4: Evolution path of the best discovered program, showing performance improvements over iterations.

The discovered program incorporates several critical modifications:

• Cycle Length Bound (CLB): Maximum cycle length increased from 130s to 240s, diluting fixed lost time and improving green allocation under congestion.
• Right-Turn Inclusion (RTI): Right-turn flows added to through demand calculations, addressing shared lane effects.
• Shared Lane Factor (SLF): Contribution of shared through–right lane reduced from 0.9 to 0.5, correcting overestimation of capacity.
• Minimum-Green Feasibility (MGF): Cycle length adjusted to ensure minimum green requirements are met.
• Post-Allocation Rescaling (PAR): Green times proportionally rescaled to match effective green budget, preventing dead time and overruns.

  Figure 5: Implementation of the initial program (initial_program.py) based on Webster's method.

  

  Figure 6: Implementation of the discovered program (discovered_program.py), with key modifications highlighted (blue dashed lines).

LLM Reasoning and Modification Examples

LLMs provided natural language reasoning for each modification, aligning with traffic engineering principles. For instance, the CLB modification was justified by the need for longer cycles in high-demand scenarios, while RTI addressed the omission of right-turn vehicles in shared lanes. SLF corrected the overestimation of shared lane capacity, and MGF ensured feasibility of minimum green constraints. PAR was introduced to optimize green allocation post-computation.

Figure 7: Example LLM response introducing the CLB modification.

Figure 8: Example LLM response introducing the RTI and PAR modifications.

Figure 9: Example LLM response introducing the SLF modification.

Figure 10: Example LLM response introducing the MGF modification.

Ablation and Incremental Analyses

Ablation studies revealed that CLB is the dominant contributor to performance gains, with its removal resulting in a 19.07% decrease in $S_c$. RTI and SLF provide secondary improvements, while PAR offers modest gains. Notably, some modifications (e.g., RTI) are detrimental in isolation but beneficial when combined with others, highlighting the importance of evolutionary search for identifying synergistic strategies. Incremental builds from the initial program confirmed these findings, with CLB alone yielding a 15.63% improvement and combined modifications producing non-additive, synergistic effects.

Exploration, Diversity, and Interpretability

Increasing the number of iterations and LLM models enhances exploration and diversity, leading to further performance improvements. However, excessive modifications can reduce interpretability and maintainability. The framework balances these factors by focusing on interpretable code and leveraging LLM-generated explanations. Discarded modifications during evolution, such as alternative saturation flow adjustments, provide additional design insights for practitioners.

Figure 11: Examples of discarded modifications observed during evolution, illustrating exploration diversity.

Figure 12: Evolution path of the best discovered program in a 600-iteration run, demonstrating further performance gains.

Practical and Theoretical Implications

EvolveSignal demonstrates that LLM-powered program synthesis can automate the discovery of interpretable, high-performance fixed-time traffic signal control algorithms. The approach bridges AI-driven code generation with domain expertise, producing executable code and natural language reasoning that facilitate human-in-the-loop refinement. The findings suggest that automated synthesis can uncover non-intuitive design patterns and synergistic strategies that are difficult to identify through manual reasoning. The framework is particularly suited for infrastructure-constrained environments where adaptive control is impractical.

Conclusion

EvolveSignal establishes a novel paradigm for traffic signal control algorithm discovery, leveraging LLMs for program synthesis and evolutionary optimization. The framework achieves substantial improvements over classical methods, with interpretable modifications and synergistic effects validated through ablation and incremental analyses. The integration of executable code and LLM reasoning enhances transparency and practical utility, enabling practitioners to adapt and refine discovered strategies. Future work will extend the approach to larger networks and more complex intersection geometries, incorporating additional LLMs and human-in-the-loop mechanisms to further enhance diversity and applicability.