Project Art
Visual Architecture of entire workflow

KINESIS: Competitive Mobility Systems Simulator

Built by : Team RedOctober

Aditya Pratap Singh
Mohd. Arham
Tanmay Mathpal

🔹 Inspiration

F1 doesn't just test speed, it tests decision-making under uncertainty. Pit strategy, energy management, overtaking windows... every race is an optimization problem unfolding in real time.

We realized the same dynamics apply elsewhere: delivery drones navigating cities, autonomous fleets coordinating routes, and traffic systems adapting to congestion.

The real question wasn't can we simulate racing? It was can we build a platform where competitive motion becomes a playground for strategy?

Most simulators are either too complex to iterate on or too rigid to generalize. We wanted something that could model F1 today and last-mile logistics tomorrow, without rewriting the engine.

KINESIS exists because the future of mobility isn’t about single agents getting faster, it’s about systems learning to compete, adapt, and optimize under pressure.

🔹 What It Does

KINESIS is a real-time, multi-agent simulation platform that models competitive mobility scenarios.
Agents move through dynamic environments, make strategic decisions, and compete for optimal performance.

Core System Features

Feature	Description
Multi-Agent Dynamics	20–30 agents share the same space with collision detection, position tracking, and event-driven state changes
Event System	Weather changes, speed zones, pit stops, and crashes force agents to adapt mid-race
Dual Control Architecture	Rule-based heuristic controllers for baseline performance, plus reinforcement learning agents trained to discover strategies
Real-Time Telemetry	Live leaderboard, agent-level metrics, and event logs streamed at 10Hz through WebSocket
Modular Design	Tracks, events, and agents can be changed or extended without altering the core engine

The output isn’t just a racing sim, it’s a testbed for competitive decision-making. Replace cars with drones, tracks with city grids, lap times with delivery throughput. The logic remains the same, only the context changes.

🔹 How We're Going to Build It

Architecture Overview

Three layers keep development parallel and integration clean.

Layer 1: Simulation Engine (Python)

Grid-based world with discrete tiles for quick prototyping, upgradable to continuous physics if needed.
Agents maintain states like position, velocity, fuel, and lap count. Events trigger through a centralized system that tracks collisions, boundaries, and pit stops.

Core Components:

Pathfinding with A*
Rule-based controllers handle acceleration, braking, avoidance, and pit logic

This ensures predictable, stable baseline behavior.

Layer 2: Reinforcement Learning Layer

The simulation wraps into a Gymnasium environment with state observations (speed, distance, obstacles, curvature), continuous actions (throttle, brake, steering), and a shaped reward function balancing progress, collisions, and fuel use.

Training uses PPO from stable-baselines3. The RL agent competes against the heuristic one, showing learned strategy versus engineered rules.

Layer 3: API and Streaming (FastAPI + WebSocket)

The backend runs the simulation loop in a background thread, exposes REST endpoints for control, and streams state snapshots every 100ms via WebSocket.
This separates simulation logic from visualization so the frontend can consume telemetry easily.

Layer 4: Dashboard (React + Canvas)

The UI uses Canvas for real-time rendering and SVG overlays for track layouts.
Leaderboard, event log, and controls allow playback, speed adjustments, and manual event injection.
WebSocket keeps everything synced live.

🔹 Challenges We Might Run Into

Challenge	How We’ll Handle It
Collision checks at scale	Spatial hashing to reduce unnecessary pairwise computations
RL training instability	Run ablations with different reward balances and tune carefully
WebSocket load	Send only changed data or lower update frequency for non-critical info
Rendering lag	Frame skipping and off-screen culling to reduce redraw load
Demo issues	Offline fallback with recorded telemetry playback
Scope creep	Focus on working sim, live leaderboard, and one trained RL agent

🔹 Built With

Simulation and AI

Python 3.10+, NumPy, Gymnasium, stable-baselines3 (PPO), NetworkX

Backend and API

FastAPI, Uvicorn, asyncio

Frontend and Visualization

React 18, Vite, Canvas API, SVG, Tailwind CSS, Axios, Native WebSocket

Infrastructure

Git, Bash, YAML

🔹 Summary

KINESIS is a platform where motion becomes strategy.
It’s a place for systems to learn, compete, and evolve, from F1 circuits to drone fleets and smart-city logistics.
A single engine, many challenges, endless ways to adapt.