However, the effective use of these existing platforms relies heavily on expert knowledge [14,25,32]. This dependence creates significant barriers for many users, particularly those from interdisciplinary backgrounds, resulting in several key difficulties: preparing simulation data is challenging, intervening in the simulation process is complex, and interpreting and optimizing the simulation results is often difficult. These issues severely limit the practical application of these platforms and hinder the effective optimization of real-world problems.

In recent years, the emergence of Large Language Models, endowed with vast common sense and powerful reasoning and planning capabilities, has made it possible to build automated workflows for complex real-world tasks. This approach has seen rapid development in fields such as WebAgent [12,38] and CodingAgent [18,30], with notable examples like WebArena [38] and SWE-Agent [30]. This success has inspired researchers in the transportation domain, leading to several new works, including TrajAgent [9], ChatSUMO [14], and SUMO-MCP [32]. However, TrajAgent [9] focuses on modeling movement trajectories, such as mobility data generation, and does not directly support traffic simulation. While both ChatSUMO [14] and SUMO-MCP [32] support SUMO-based traffic simulation, they are limited to the automated execution of a fixed set of scenarios and parameters. Crucially, they all lack systematic automatic optimization and feedback capabilities, preventing effective iterative improvement and optimization.

To address the aforementioned challenges, we propose Traf-ficSimAgent, a novel LLM based multi-agent framework for autonomous traffic simulation. Specifically, TrafficSimAgent introduces three core components: first, it defines and abstracts API functions, decoupling them from the underlying traffic simulation platform and packaging them as MCP Functions to support automatic calling by the LLM Agents; second, it features a Task Understanding and Autonomous Planning module that automatically interprets vague natural language instructions, enabling the agent to freely combine underlying functional modules and break away from the fixed workflows, which significantly enhances the generality and adaptability of the automated simulation system to different scenarios; and finally, integrated with the simulation process, it includes a built-in system optimization module that supports both a full-stack automatic optimization driven entirely by LLM and a two-layer optimization logic combining the LLM’s strengths with classical low-level optimization algorithms.

The main contributions of this paper are summarized as follows: • To the best of our knowledge, we are the first to propose an autonomous traffic simulation agent capable of both automatic optimization and scenario generalization.

Data config • We introduce a set of Abstracted API Functions, decoupled from the underlying traffic simulation platform and exposed via the MCP interface, establishing a foundational infrastructure for general-purpose autonomous traffic simulation. • We design a novel Task Understanding and Autonomous Planning module that supports the interpretation of ambiguous natural language instructions and enables multi-scenario generalization, thus allowing the system to adapt to diverse environments. • We propose an Embedded Optimization Module featuring a two-layer optimization system: one based on fully autonomous LLM-driven optimization, and another combining the LLM with classical algorithms. This enables self-optimization of the simulation and performance improvement. • Extensive experiments demonstrate the generalization and stability of our proposed framework across various simulation scenarios. Furthermore, its automatic optimization capability enables automated, iterative performance improvement tailored to specific task requirements.

TrafficSimAgent is designed as a collaborative multi-agent framework that bridges natural language instructions and traffic simulation execution. As shown in Figure1, our framework consists of four core modules working together:

LLM agents act as experiment planners and optimizers. According to the general implementation of transportation experiments, we design a task understanding module, three task execution modules-including a map generator module, a trip generator module, and a simulation executor module-each managed by an LLM agent.

To assist each agent in better understanding the specific implementation plan and enabling efficient collaboration among agents, we design an Orchestrator module that serves as a global planner and a Context Manager that functions as a shared memory pool. The workflow begins with the Task Understanding Module interpreting user instructions. The Orchestrator then decomposes the task into subtasks and routes them to appropriate executors. Each executor module organizes experiments automatically and invokes necessary tools via the MCP server. Throughout this process, the Context Manager maintains execution history and agent memories, enabling reflection and learning. The server, built on the MCP-agent framework, dynamically registers and runs only the necessary tools-such as MOSS utilities and other auxiliary utilities-via a lightweight JSON-RPC interface.

The module understands the user’s instructions, then recognizes key parameters for each executor module; detailed parameters are provided in Table1. The module also performs global planning, assigning the execution order of each module according to the user’s instructions.

For example, the instruction: “compare the TSC experimental results of Yizhuang during morning peak hour and Shanghai at midnight” corresponds to the following execution order: map generator → trip generator → simulation executor → map generator → trip generator → simulation executor.

Task Executor Module The module consists of three submodules.

(1)Map Generator: Generate traffic network maps according to the parameter region. First, use the geocoding service of OSM (OpenStreetMap) to obtain the coordinates of the four corners of the region boundary. Then, fetch POI, AOI, street, lane, and junction data within the boundary from OSM in GeoJSON format. Finally, use GeoBuilder to convert the GeoJSON to Protocol Buffer (Protobuf) format, while also performing lane reconstruction and traffic light generation within intersections.

(2)Trip Generator: Generate trip files for vehicles and persons for simulation. First, generate user profiles and departure time curves in parallel with the distribution described in the user instructions. Then, generate the OD matrix (Origin-Destination matrix) for persons and vehicles (drivers) in the target region. Finally, set personalized driving patterns for each driver and use routing algorithms to generate travel paths based on the OD matrix. It also supports post-processing map data if required for specific tasks. For example, removing the yellow light phase from the map for TSC (Traffic Signal Control) tasks.

(3)Simulation Executor: Execute simulation tasks and choose the optimal execution strategy according to the user instructions. We categorize tasks into online simulation and offline simulation. Offline simulation involves modifying static elements, such as AOI, street, lane, and junction data. Online simulation involves modifying dynamic elements by analyzing real-time information collected during the simulation, such as adjusting vehicle driving states based on road conditions and changing traffic light phases at intersections in real time. Online simulation supports both traditional RL algorithms and LLM agent-controlled methods to collect environmental information, calculate current rewards, and determine update strategies for future states of dynamic elements.

Orchestrator Module This module functions as an agent router, decomposing complex tasks into sub-tasks and routing each subtask to the relevant module’s agent. It supports multi-agent parallel task execution, monitors the execution process, and aggregates the execution results from each module.

Context Manager Module This module consists of a global context manager and multiple individual memory managers. The global context manager oversees the execution results of each module and shares key parameter information between modules. Once the task understanding module receives the user’s instructions, the context manager creates a new session to record the context history of each task executor module, including tool parameters, tool execution order, and error messages. Task executor modules can perform reflection based on this history to enhance task execution success rates. The memory managers record the decision history of each agent in the simulation executor module, adaptively updating as simulation time progresses, enabling agents to recognize and learn from the highest-reward decisions.

Please optimize traffic flow through the coordinated control of traffic signals and vehicles in female-driverdominated scenarios.

Extract key parameters

The tool function failed to execute due to ambiguous key input parameters.

I can only modify traffic signal phases. There are also some auxiliary tools in Table1 to facilitate a higher task execution success rate.

The architecture of TrafficSimAgent is specifically designed to achieve superior generality across diverse simulation scenarios, overcoming the limitations of previous systems that rely on predefined workflows and limited task support. This enhanced generality is realized through three key design innovations: robust instruction understanding, dynamic task planning, and flexible element-agent embodiment.

Understanding through Semantic Comprehension. Unlike pattern-based approaches such as ChatSUMO that extract predetermined parameters through template matching, Traf-ficSimAgent ’s Task Understanding Module employs deep semantic comprehension to handle ambiguous, incomplete, or contextdependent instructions. The module utilizes LLM-powered analysis to infer implicit parameters and contextual relationships, then structures this understanding into standardized configuration files for downstream processing. This approach significantly expands the range of acceptable instructions beyond predefined templates, enabling natural and flexible user interaction while maintaining structured data flow between modules.

Traditional systems like ChatSUMO employ fixed execution workflows that limit their applicability to predetermined scenarios. Traf-ficSimAgent overcomes this limitation through its Orchestrator Module, which dynamically plans and adapts execution sequences based on semantic understanding of each unique instruction. We show a case in Figure2.

The dynamic planning process enables handling of complex, multi-faceted instructions that would require manual workflow specification in previous systems. For instance, the comparative instruction “analyze traffic patterns in Shanghai between morning and evening peaks, then optimize signal timing for the worstperforming period” triggers the following adaptive workflow: (1)Map generation for Shanghai region. (2)Trip generation with morning peak profile parameters. (3)Simulation execution and metric collection. (4)Trip regeneration with evening peak profile parameters.

(5)Simulation execution and metric collection. ( 6)Comparative analysis and bottleneck identification. (7)Targeted optimization of identified critical intersections. ( 8)Validation simulation and results reporting. This flexible planning capability allows TrafficSimAgent to accommodate diverse instruction types without requiring predefined workflow templates, significantly expanding its applicability across different experimental designs.

The framework’s generality is further enhanced by its foundational principle of element-agent embodiment, where each fundamental traffic element (e.g., an intersection, a vehicle) is represented by an LLM agent that makes autonomous decisions in real-time based on environmental information. This architecture supports a wide range of simulation tasks through emergent agent behaviors rather than hardcoded scenario implementations. For example, the fusion task requires coordinated decision-making between agents role-playing traffic signals and those role-playing vehicles. Each agent optimizes its behavior while considering the others’ states and intentions, without the need for pre-programmed coordination logic.

TrafficSimAgent ’s autonomous optimization capability is achieved by employing LLM agents to act as fundamental traffic elements and make coordinated decisions based on real-time states, moving beyond merely functioning as an on/off switch for the simulation process. This optimization operates at two levels: high-level optimization strategy selection and low-level real-time collaborative optimization. The Context Manager Module enables agents to reflect on their execution records and rewards from environment, continuously improving success rates.

Module is able to automatically select the most suitable optimization approach based on user instructions and task characteristics. For tasks requiring precise numerical optimization (e.g., “minimize average travel time”), it may invoke traditional optimization algorithms such as MaxPressure or reinforcement learning-based methods. For tasks demanding commonsense reasoning and complex trade-offs (e.g., “reduce congestion while maintaining safety”), it employs LLM-based optimization strategies. This adaptive selection mechanism ensures optimal performance across diverse scenarios.

Real-Time Collaborative Optimization. During simulation execution, low-level agents achieve real-time closed-loop optimization of traffic conditions through perception-decision-action cycles. Each agent (e.g., traffic signal or vehicle) makes decisions considering not only its own state but also the cooperative status of other elements and real-time traffic conditions information. For instance, a traffic signal agent adjusts phase timing by comprehensively analyzing current queue lengths, pressure in the neighbourhood, the intentions of approaching vehicles, and overall regional traffic density. Similarly, a vehicle agent selects optimal acceleration and speed while considering signal states ahead and the cooperative behavior of surrounding vehicles. This multi-element collaborative decision-making mechanism overcomes the limitations of traditional algorithms (e.g., MaxPressure, MPLight) that utilize only localized neighborhood information, and existing LLM-based methods (e.g., LLMLight) that inadequately consider the status of other elements

TrafficSimAgent utilizes MOSS as the simulator with an MCP-agent. Users input natural language instructions at the client side, and related tools are subsequently invoked at the server side. Variables parsed from these instructions and intermediate variables (for example, data paths and the boundary coordinates of the target region) are stored in the context manager. Instead of relying on a predefined workflow and setup, we employ an Orchester module to plan the execution sequence and assign reasonable values to parameters in the configuration file, guided by the natural language instructions. We also enable LLM agents to optimize the experimental results during the simulation process, rather than merely functioning as an on/off switch. Therefore, we primarily aim to demonstrate the versatility and autonomous optimization capability of TrafficSimAgent.

3.1.1 Baseline Models and Methods. To comprehensively evaluate the performance of TrafficSimAgent, we compare it against a range of baseline approaches, categorized into two groups for the main experiment and the optimization experiment, respectively.

Baselines for Main Experiment We select baselines that represent different paradigms in task automation and language-driven simulation:

• Domain-Specific Agent Frameworks: ChatSUMO [14], a specialized framework that integrates LLMs with the SUMO simulator for traffic simulation tasks. • General-Purpose Agent Frameworks: OpenManus [15] and MetaGPT [11], which are state-of-the-art, multi-agent frameworks designed for general software task execution but not specifically tailored for traffic simulation. • General Large Language Models (LLMs): GPT-5 and Gemini 2.5 Pro [6]. These powerful models are prompted to perform the simulation tasks in a zero-shot or few-shot manner, representing the capability of raw LLMs without specialized frameworks.

Baselines for Optimization Experiment To specifically assess the optimization capability of our low-level agents, we compare against established Traffic Signal Control (TSC) algorithms:

• MaxPressure [16]: A classic, model-free TSC algorithm that controls signals based on the real-time pressure (queue length) of incoming and outgoing lanes. • MPLight [5]: A deep reinforcement learning-based method that utilizes the MaxPressure principle as part of its reward function for adaptive signal control. • LLMLight [13]: A state-of-the-art LLM-based TSC method that leverages large language models for decision-making at intersections.

All experimental data were generated on-demand by our TrafficSimAgent via the MOSS simulation environment, including a map network and travel demand data. The data generation was directly guided by the user’s natural language instructions, ensuring each scenario accurately reflects the specified conditions.

Map Network Dataset comprises the fundamental topological and geographical elements required for traffic simulation, which is generated by the Map Generator in executor module through the following procedure:

(1)Geocoding: Given a region name (e.g., “Yizhuang, Beijing”), we utilize the OpenStreetMap (OSM) geocoding service to obtain its precise geographical boundaries (i.e., the four-corner coordinates).

(2)Data Fetching & Conversion: The bounding box is used to fetch raw map data from OSM, which is then converted into a simulation-ready network using the MOSS simulator’s utilities. The final map dataset comprises several core elements: lanes, roads, junctions, and AOIs (Areas of Interest).

Travel Demand Dataset defines the movement of individuals and vehicles, which is generated by the Trip Generator in executor module through the following procedure:

(1)OD Matrix Generation: An Origin-Destination (OD) matrix is first generated based on an analysis of map dataset generated by Map Generator.

(2)Individual Demand Synthesis: The aggregate OD matrix is then disaggregated into individual travel demands. This critical step is guided by the natural language instruction and involves intelligently determining several key parameters. To enhance the robustness of this process, Context Manager Module enables reflective validation, ensuring the selected parameters and scenario configurations are contextually appropriate and consistent with the user’s intent. Key parameters are as follows:

• Population Size: The total number of users to simulate.

• Origin-Destination Selection: Choosing specific start and end points (AOIs) that reflect the instructed scenario. • Travel Mode: Assigning modes of transport (e.g., car, taxi, walk). • User Profiles: Generating demographic profiles for each individual, including age, gender, education, and consumption level. • Departure Time Distribution: Configuring a time distribution curve for trip departures (e.g., a peak-shaped curve for “rush hour”). • Driving Parameters: Configuring either personalized or unified driving behavior parameters (e.g., usual acceleration, average speed) for each vehicle.

(3) Simulation Integration: The generated individual trips are finally integrated with the road network for execution in the simulator.

The key parameters used in the travel demand generation are summarized in Table 1.

To comprehensively evaluate the performance of all methods, we employ a set of metrics from traffic simulation, categorized into efficiency and environmental impact dimensions. Efficiency is measured by traffic volume (TV), cumulative throughput, travel time (ETA, ATT-finished), queue length (AQL), and ETA reduction (ΔETA); environmental impact is gauged by total and average carbon emissions (Carbon, ACE). Formal definitions are provided in Appendix A.

To demonstrate the ability of TrafficSimAgent to handle various types of natural language instructions, we designed a natural language instruction benchmark covering diverse scenarios across different simulation tasks, categorized into “specified” and “ambiguous” instructions. The model was tasked with two ambiguous instruction to simulate driving behaviors of two distinct demographic groups: middle-aged, middle-income drivers with median education levels(Middle Aged Middle Income), and female-dominated driving populations(Female Dominant). The generated results are presented in Figure 3 and Fig 4, showing distributions that align broadly with the specified instructions, illustrating that it genuinely understands ambiguous instructions instead of mechanically parsing parameters from them. Furthermore, we sought to evaluate the general capability of TrafficSimAgent on both online and offline simulation tasks. We selected medical service selection as the offline simulation task, and auto_drive, TSC (Traffic Signal Control), and fusion as the online simulation tasks. We compared the results of TrafficSimAgent against a general model, a general agent framework, and a domain-specific agent framework. Table 2 presents the comparison results.

The results indicate that ChatSUMO, the domain-specific model, can only handle the TSC task. GPT-5 and Gemini-pro, the general models, show limited performance in either congestion mitigation (high AQL) or economic and environmental efficiency (high carbon emission). MetaGPT, as a general agentic framework, adopts an overly conservative strategy (low TP, low AQL), whereas Open-Manusor adopts the opposite approach (high TP, high AQL). In contrast,TrafficSimAgent strikes a balance among TP, AQL, and carbon emission, enabling all vehicles to complete their trips as quickly and smoothly as possible without excessive congestion, thereby avoiding carbon emissions caused by inefficient acceleration near the speed limit.

We evaluated the traffic optimization results by comparing Traffic-SimAgent with traditional TSC algorithms (MaxPressure, MPLight) and LLMLight, a state-of-the-art LLM-based TSC algorithm. Experiments were performed using the aforementioned dataset. The comparison results are shown in Table 3. TrafficSimAgent, which employs LLM agents for macro-level traffic condition optimization by controlling individual traffic elements in consideration of current traffic conditions and the status of other elements, proves to be the optimal approach. Specifically, the fusion algorithm performs best by enabling cooperative control between traffic lights and vehicles. LLMLight fails to adequately consider the information from other elements, while traditional algorithms only utilize neighborhood information, leading to a suboptimal overall optimization outcome.

To analyze the advantages of our framework over traditional LLMbased TSC implementations like LLMLight, which typically provides junction phase information to traffic signal agents at each step, we compare the evolution of traffic throughput and carbon emission across simulation steps, as shown in Figure 5. The experimental results reveal that our method’s superiority becomes increasingly pronounced as simulation progresses. This emergent advantage stems from a fundamental difference in decision-making paradigms. While conventional approaches like LLMLight rely on fine-grained phase analysis (providing per-phase queue lengths for each junction), our low-level agents operate under a reinforcement learning-inspired philosophy that maximizes a composite reward function incorporating pressure differences between incoming and outgoing lanes, total queued vehicles, and neighboring junction influences. This reward-driven approach creates a critical shift from shortterm reactive decisions to long-term strategic optimization. The phase-specific information used by traditional methods often leads to greedy decisions that minimize immediate queue lengths but disrupt the balance between intersection pressure and overall traffic throughput. In contrast, our agents leverage historical trend analysis through the scratchpad mechanism (e.g., strategy: try-betteraction) to learn from long-term outcomes rather than reacting to instantaneous snapshots.

Our goal-oriented reward signal combined with memory-enabled strategic decision-making drives more effective long-term optimization. Besides, Historical State maintains strategy effectiveness through action-reward memory; Other Junctions enables coordinated multi-agent optimization; and the Scratchpad provides essential trend analysis for adaptive decision-making. In conclusion, our framework’s growing advantage over traditional phase-analysis approaches underscores the effectiveness of replacing detailed perceptual data with goal-driven, history-aware decision processes for complex dynamic optimization in traffic signal control.

Our experiments with varying model sizes in Table 4 demonstrate a clear positive correlation between parameter count and performance. The Qwen3-235B model achieves overall superior results, while smaller models show progressively reduced capability. This confirms that TrafficSimAgent ’s performance scales with the underlying model’s capacity.

Traffic simulation has long been established as a cornerstone of urban computing and intelligent transportation systems research [22,24,31]. High-fidelity, open-source simulators such as SUMO [2], MOSS [36], MATSim [25] and CityFlow [35] provide researchers with powerful platforms for modeling complex traffic dynamics, evaluating traffic management policies, and testing autonomous driving algorithms. There are also traffic simulator for auto-drive, such as LCSim [37] and CARLA [8]. These tools offer extensive libraries for network modeling, vehicle movement, and traffic light control. However, conducting simulation experiment remains a non-trivial task that often poses significant challenges for users. For example, many autonomous driving-related studies based on SUMO are designed to perform each simulation step manually, such as SMDT [27], BlaFT [17], HPTSim [19], DLIO [26], ASC-HBMP [39], and RoboCar [23]. Moreover, the very process they manually execute is inherently complex, typically involving multiple intricate steps: acquiring and preprocessing map data (e.g.,

Recent works have begun leveraging large-language models (LLMs) within agentic frameworks to automate complex tasks through natural language instructions, demonstrating significant potential in lowering the barrier to entry for non-expert users. The emergence of autonomous AI agents has showcased LLMs’ capability in task decomposition and sequential execution, while specialized systems such as ChemCrow [4] have demonstrated expert-level automation in scientific domains like organic synthesis and drug discovery. In cybersecurity, AutoPentest [10] exemplifies how LLM agents can autonomously conduct penetration testing and vulnerability assessment. In trajectory modeling, TrajAgent [9] unifies various trajectory modeling task through a collaborative agentic framework. Particularly impressive is Coscientist [3], which autonomously designs, plans, and executes real-world chemical experiments, successfully completing complex palladium-catalyzed cross-couplings. Recently there are also many works on general agent framework, such as AutoGen [29] and ChatDev [18]. This trend is particularly evident in traffic simulation domains, where LLM-powered agents can interpret high-level commands and execute corresponding simulator actions. For instance, Chat-SUMO [14] employs LLMs as a natural language interface to the SUMO simulator, allowing users to issue intuitive commands (e.g., “I want to see traffic in Albany… “) that are automatically translated into executable simulator configurations. Similarly, Open-TI [7] proposes an agentic workflow where users provide natural language instructions through an LLM interface, which then autonomously starts and manages SUMO simulations in the background. These approaches exemplify the broader movement toward LLM-based automation systems that transform abstract user requirements into precise technical operations.

There are also works propose LLM-assisted frameworks to solve traffic signal control (TSC) problems, integrating SUMO for traffic simulation and algorithm validation, such as CityLight [34], LLMAATSC [20], LLMLight [13], CoLLMLight [33], LLM-assisted light [28], and LLMDUTSC [21]. A more recent and powerful paradigm is the use of Model Context Protocol (MCP) [1]. Frameworks like SUMO-MCP [32] begin to leverage this concept by wrapping SUMO’s functionalities into MCP-compatible tools. However, these works are constrained by several key limitations. Firstly, their capabilities are often bounded by pre-defined, rigid workflows, lacking the flexibility to dynamically plan and adapt a comprehensive experimental procedure from scratch. Secondly, their generality is limited: they are often tightly coupled with a narrow set of tasks (e.g., TSC), making it difficult to extend them to a broader range of scenarios. Most critically, they lack a robust mechanism for outcome optimization or fails to enhance global performance, such as minimizing overall travel time, congestion or carbon emission.

In this paper, we introduced TrafficSimAgent , a novel LLM-based multi-agent framework designed to overcome the generality and optimization bottlenecks in traditional traffic simulation workflows. By leveraging a hierarchical architecture of collaborative agents and the carefully designed model context protocol for traffic simulation, TrafficSimAgent translates natural language instructions into executable simulation plans and enables real-time, intelligent optimization of traffic conditions.

Our work makes several key contributions. First, we demonstrate that TrafficSimAgent possesses enhanced generality, capable of handling both specified and ambiguous instructions across diverse online and offline simulation scenarios. Second, we showcase its autonomous optimization capability, where low-level agents, embodying traffic elements, make coordinated decisions that outperform traditional and contemporary LLM-based TSC algorithms. Our analysis on agent reasoning components further shows that good performance stems from a combination of a goal-oriented reward signal and a memory-driven strategy.

Despite its promising results, the current framework has some limitations. The performance and token consumption are inherently tied to the capabilities and scale of the underlying general-purpose LLMs. For future work, we plan to investigate task-specific finetuning of more compact language models to reduce computational and token overhead while maintaining performance. Furthermore, we will explore to extend the framework to support multi-modal instructions and integrating it with a broader range of urban simulation platforms.