CARJAN: Urban Traffic Scenario Simulation
- CARJAN is an open-source tool for semi-automated generation and simulation of urban traffic scenarios featuring multi-agent interactions using AJAN and the CARLA simulator.
- It employs SPARQL Behavior Trees for dynamic, context-aware agent decision-making, enhancing explainability and modularity during simulation.
- The system integrates a visual editor, semantic modeling, and live simulation feedback to streamline scenario design, storage, and iterative experimentation.
Searching arXiv for CARJAN and closely related papers to ground the article in current literature. CARJAN is an open-source tool for the generation and simulation of urban traffic scenarios with multiple interacting agents such as pedestrians, cyclists, and autonomous vehicles. It is presented as a semi-automated approach that combines the AJAN multi-agent engineering framework with the CARLA driving simulator, and it centers agent behavior on SPARQL-extended Behavior Trees embedded in a visual modeling and simulation workflow (Neis et al., 29 Aug 2025). In this formulation, CARJAN addresses user-friendly modeling, storage, maintenance, execution, and inspection of virtual traffic scenarios, with particular emphasis on dynamic interactions and explicit agent decision structures rather than purely script-based scenario specification.
1. Definition and scope
CARJAN is described as a novel tool for semi-automated generation and simulation of urban traffic scenarios based on the multi-agent engineering framework AJAN and the driving simulator CARLA (Neis et al., 29 Aug 2025). Its stated domain is urban traffic scenario modeling with different types of interacting agents, specifically pedestrians, cyclists, and autonomous vehicles. The central problem it targets is that user-friendly modeling and virtual simulation of such scenarios remains a challenge.
The system is positioned as an integrated approach rather than a standalone editor or a standalone simulator. It provides a visual user interface for the modeling, storage and maintenance of traffic scenario layouts, while also leveraging SPARQL Behavior Tree-based decision-making and interactions for agents in dynamic scenario simulations in CARLA. This dual focus on scenario design and executable agent logic is fundamental to its definition.
A plausible implication is that CARJAN is intended not merely for scene construction but for closed-loop experimentation on traffic interactions. The paper’s emphasis on integrated generation, simulation, and monitoring suggests a workflow in which scenario geometry, semantic world state, and agent policy specification are treated as interdependent artifacts rather than separate stages.
2. System architecture and integration pathway
CARJAN consists of four main components: the AJAN Framework, the CARJAN GUI/Editor, the carjanService middleware, and the CARLA simulator (Neis et al., 29 Aug 2025). AJAN provides semantic agent management and Behavior Tree-based behavior modeling. The GUI is a web-based interface, referred to as AJAN-Editor, for graphically designing scenarios and agent behaviors. The carjanService is a Flask-based server that mediates between the user interface, the agent backend, and CARLA. CARLA is the execution environment for urban traffic scenarios and provides realistic rendering and physical simulation.
The architectural pipeline is explicitly functional. The scenario model is represented in RDF, agent behaviors are represented as SPARQL-BT structures, and carjanService performs transformation, communication, launch, and synchronization with CARLA. The paper summarizes this as:
$\text{CARJAN} : (\text{Scenario Model}_{\text{RDF}, \;\text{Agent Behaviors}_{\text{SPARQL-BT}) \xrightarrow{\text{carjanService} \text{CARLA Simulation}$
It further characterizes agent decision-making at simulation time as:
$\text{Action}_t = \mathrm{BT}_{\text{Agent}\big( \mathrm{SPARQL}(K_t) \big)$
Within this design, AJAN contributes semantic reasoning over RDF data and exposes REST APIs for integration with external systems. CARLA, by contrast, is presented as a simulator whose scenario definition is natively Python-based and can be laborious and error-prone without intermediary tools. CARJAN’s integration layer is therefore not incidental: it is the mechanism by which GUI actions, semantic agent control, and simulator execution are kept synchronized.
This architecture suggests a deliberate separation of concerns. Scenario representation, behavior representation, middleware orchestration, and simulation runtime are handled by distinct components, but they are connected tightly enough to support live re-generation and one-click execution. That separation is also what enables CARJAN to present itself simultaneously as an editor, a semantic modeling environment, and a simulation frontend.
3. Agent model and SPARQL Behavior Trees
Behavior in CARJAN is encoded through SPARQL Behavior Trees, combining the hierarchical control structure of Behavior Trees with SPARQL queries over semantic world models (Neis et al., 29 Aug 2025). The node types identified in the paper are condition nodes, action nodes, and control nodes such as Sequence and Selector. Condition nodes use SPARQL queries to check world state or agent knowledge; action nodes trigger agent or world changes; control nodes structure execution flow.
The paper gives a pedestrian example organized as a sequence: approach curb, check for approaching cars, cross the street if safe, and execute a “look over shoulder” animation. In the notation presented there:
In this example, CarApproaching is a SPARQL query over the RDF environment.
A key property of this formulation is that the Behavior Tree responds in real time to changes in the environment because the agent’s behavior is tied directly to semantic knowledge updated during simulation. The paper therefore frames CARJAN’s decision model as dynamic and context-aware rather than static or pre-scripted. It also describes the resulting behavior model as declarative, modular, and semantic.
The significance of SPARQL-based decision-making is articulated along three axes. First, semantic awareness: actions are informed by live queries against a world model. Second, explainability: SPARQL BTs and real-time visualization make the mapping between scenario state, agent “thought process,” and behavior explicit. Third, modularity and reuse: the BT formalism and RDF scenario structure support composition and iterative refinement. A plausible implication is that CARJAN is particularly suited to debugging interaction logic in heterogeneous urban scenes, where discrete situational predicates can matter as much as kinematic realism.
4. Scenario modeling, storage, and maintenance
CARJAN’s scenario modeling environment is visual and web-based. The interface provides a grid-based traffic layout with drag-and-drop construction of roads, junctions, sidewalks, and obstacles, and it includes specialized templates for intersections and road segments (Neis et al., 29 Aug 2025). Agents and entities can be placed, configured, and assigned behaviors on the map. Path and area specification are supported through waypoints and Bezier curves, while “decision boxes” define special zones that trigger agent behavior, such as a pedestrian waiting at a crossing until it is safe.
Behavior assignment is integrated directly into scenario design. Each pedestrian, cyclist, or vehicle is linked to a SPARQL Behavior Tree, and predefined BT action sets are provided to facilitate rapid behavior modeling. This is important because it means the editor is not limited to geometry or route planning; it also acts as a behavior configuration environment.
For storage and management, the internal scenario model is represented as RDF quads in TriG format, reflecting entities, positions, attributes, and meta-data. Agent knowledge and world state are maintained in dedicated AJAN triple stores. The system supports saving scenarios locally or on GitHub for versioning and sharing. Temporary editing changes are managed in a JavaScript-based state store to avoid unnecessary server trips and optimize responsiveness, after which finalized changes are saved back as RDF quads.
Maintenance spans both offline editing and online modification. The paper states that modifications can be made during or between simulation runs, and that the interface provides instant visual feedback such as color changes and icon updates. The LiveBehavior overlay extends this maintenance capability into runtime inspection by providing real-time monitoring of agent BT executions through color-coded node status indicators for active, succeeded, and failed nodes. This makes CARJAN not only a design environment but also an instrumentation environment for agent behavior analysis.
5. Simulation workflow and execution semantics
CARJAN’s simulation workflow is described as integrated: after each scenario or agent edit, a simulation session can be triggered from within the GUI, with users observing both traffic flow and agent Behavior Tree execution (Neis et al., 29 Aug 2025). The middleware synchronizes the current scenario state and BT logic with CARLA, with the stated purpose of eliminating errors associated with manual script-based scenario management.
The execution model distinguishes between synchronous and asynchronous commands. Synchronous commands correspond to immediate actions, whereas asynchronous commands correspond to long-running or animated tasks. This distinction is used to ensure correct execution flow in simulation. In practical terms, that separation is necessary when agent behavior includes not only symbolic decisions but also animations, locomotion, and temporally extended tasks.
The paper also emphasizes real-time scenario re-generation and a “one-click” user action for launching live simulation through the middleware. This matters because the bottleneck in scenario-based testing is often not pure simulation runtime but the iteration loop between editing, launching, observing, and revising. CARJAN is designed to compress that loop by keeping the editor, the semantic agent backend, and the simulator continuously interoperable.
This suggests that CARJAN occupies an intermediate methodological space between manual CARLA scripting and fully opaque automated generation. The system remains interactive and model-driven, but it also automates translation and synchronization tasks that would otherwise be handwritten and potentially inconsistent.
6. Comparative position and distinguishing characteristics
The paper compares CARJAN with SCENIC and OASIS along several dimensions, including declarative agent behavior modeling, visual editing, integrated simulation and modeling, explainability, open-source availability, supported agent types, and real-time behavior monitoring (Neis et al., 29 Aug 2025).
| Feature | CARJAN | SCENIC / OASIS |
|---|---|---|
| Declarative agent behavior modeling | Yes (SPARQL BT) | No (scripts, constraints) / No (visual/event scripting) |
| Visual editor | Yes | No / Yes |
| Integrated simulation & modeling | Yes | No / Partial |
| Agent decision explainability | Yes (LiveBehavior) | No / No |
| Real-time behavior monitoring | Yes | No / Partial |
The differentiators identified in the paper are SPARQL Behavior Trees, the integrated UI, explainability through LiveBehavior, and RDF-based model management. The comparison is not framed as a rejection of alternative approaches, but as a statement about what CARJAN adds: a single tool that combines interactive scenario construction, semantic agent logic, execution in CARLA, and live visibility into decision flow.
A plausible implication is that CARJAN is particularly relevant when scenario design requires heterogeneous agents with explicit, inspectable policies. By contrast, approaches centered on scripts, constraints, or event scripting may provide alternative forms of expressiveness, but the paper presents them as lacking the same combination of declarative behavior modeling and live decision transparency.
7. Interpretation, significance, and common confusion
The significance attributed to CARJAN lies in its support for interactive, intelligent agent-based generation and simulation of virtual traffic scenarios in CARLA (Neis et al., 29 Aug 2025). The paper stresses semantic awareness, explainability, modularity, and reuse. In that sense, CARJAN is not merely a scenario editor layered on a simulator; it is a semantic multi-agent workflow for constructing, executing, and inspecting urban traffic interactions.
One common source of confusion is terminological rather than technical. CARJAN is distinct from CAR, the “Cityscapes Attributes Recognition” dataset, which extends Cityscapes with object-level attribute annotations for autonomous vehicle research (Metwaly et al., 2021). CAR is a dataset and annotation resource with a tailored taxonomy and an API for data access, whereas CARJAN is a generation-and-simulation tool built around AJAN, CARLA, RDF quads, and SPARQL Behavior Trees. The shared prefix should not obscure that the two artifacts operate at different layers of the research stack: one concerns richly annotated perception data, the other scenario modeling and interactive simulation.
More broadly, CARJAN can be understood as part of a methodological shift toward semantically grounded simulation environments for traffic research. Because its agent decisions are formulated as Behavior Tree evaluations over a knowledge graph, the system foregrounds explicit state representations and interpretable control flow. This suggests utility in settings where inspection, debugging, and iterative refinement of agent interactions are at least as important as visual fidelity or raw simulation throughput.