-
System architecture
HorsePower Arena: Approach to Building a Multi Agent Mobility Event Simulator
Inspiration
The problem statement we received was straightforward: create a multi agent mobility event simulator that models various autonomous agents, simulates their interactions, and outputs a live leaderboard. At first, it seemed like a simple simulation task, but as we began exploring the idea, it quickly became clear that this would require a robust system capable of handling the dynamic complexity of multiple agents interacting in real time environments.
Our goal is not just to create a static world but to design a system where agents react, adapt, and evolve based on real time data. This is similar to how autonomous vehicles or drones navigate and make decisions in real world situations, which motivated us to build a system that could simulate that level of complexity and interaction.
What We’re Learning
As we move forward, we’re learning that creating this system is more challenging than we initially thought. The first key lesson was understanding that designing a multi agent system isn’t as simple as placing agents in a simulation and letting them move around. The real challenge lies in real time communication, event tracking, and performance updates across all agents. The ROS2 framework is essential for managing communication and ensuring synchronization between agents. However, the complexity increases as we process multiple data streams, especially when each agent must interact with the environment in real time.
We are incorporating computer vision for object detection (with YOLOv8) and LiDAR for navigation, but these tools come with their own set of challenges. While they are powerful, they are also computationally expensive, and running this simulation in real time on a non GPU system is proving to be difficult. This has forced us to focus on performance optimization and how to balance high fidelity with hardware limitations, ensuring that the simulation can still run effectively on different systems without losing critical details.
Building the Project
We’ve started with setting up the multi agent system, using ROS2 to manage communications and control logic for each agent. For the simulation environment, we’ll use Gazebo, which will allow us to create different worlds (such as race tracks or city streets) and test how agents behave in these environments.
The real challenge so far has been in event tracking and leaderboard updates. We need a system that can collect data like lap times, overtakes, and collisions, process it in real time, and update the leaderboard instantly. The plan is to break the system into modular components that handle the agent states and performance metrics independently. These components will then synchronize to update the leaderboard in real time.
Approach
To tackle this, our approach is to break the system down into modular components. Each component will be responsible for specific tasks:
-Agent State Management: A component will track each agent’s current position, velocity, and status (whether the agent is racing, crashed, or has finished the race). This will ensure that every agent’s state is being constantly updated in real-time.
-Event Tracking: Another component will handle events like lap completions, overtakes, and collisions. This will use ROS2 to subscribe to relevant agent data and process it as the simulation progresses.
-Performance Metrics Collection: A third component will collect and process performance data such as lap times, agent speed, and overall race completion times. It will use this data to generate real-time performance metrics for each agent.
-Leaderboard Synchronization: Finally, we’ll have a component that aggregates the data from all other modules and updates the leaderboard in real time. This component will calculate the rankings based on lap times, position, and event performance (such as overtakes or collisions) and dynamically update the leaderboard for participants and spectators to see.
These modular components will work independently to manage specific tasks, but they will be synchronized through ROS2 for real-time data exchange. This ensures that, as each agent’s behavior evolves, the leaderboard remains up to date without lag.
We’re also focusing on scalability. As we add more agents, ensuring that the simulation can handle the increasing computational load while still providing real time updates is critical. The more agents and complex the environment, the more performance becomes an issue. We’re working on solutions to address this as we continue developing.
Challenges We’re Facing
The biggest challenge we are currently facing is performance optimization. Simulating multiple agents in real time, especially when using tools like YOLOv8 and LiDAR, is computationally heavy. Without a GPU, running these simulations effectively is proving difficult, and we must figure out how to balance simulation fidelity with the hardware constraints we have, though we have also arranged for a GPU enabled system to test the efficiency. Our goal is to maintain high quality simulations while ensuring they remain responsive and perform well.
Another challenge we’re currently tackling is scalability. The system is designed to be containerized, which will help us scale it. But as we add more agents, keeping everything running smoothly in real time is becoming more difficult. The more complex the world and the more agents we simulate, the more performance becomes an issue.
Lastly, event tracking and leaderboard updates are harder than expected. Tracking metrics like lap times, overtakes, and collisions in real time while keeping everything synchronized and updating the leaderboard instantly is a complex problem. Ensuring that this system is both accurate and efficient is one of our main goals moving forward.
Conclusion
So far, the process of building it has been more challenging than we first anticipated. What started as a problem to simply simulate agents interacting in a race or traffic environment is turning into a complex lesson in system design, optimization, and real time data processing. We are focused on creating a scalable, functional solution that simulates real time mobility events, tracks agent performance, and outputs a dynamic leaderboard. At the same time, we are working to ensure that the system is adaptable to varying hardware constraints and environments, whether running on high-performance systems or non GPU systems.
