A multi-agent AI orchestration platform for real-time crowd intelligence, crisis prediction, and autonomous coordination at mega-scale urban events.

🔴 LIVE DEMO → http://olympusos.ddns.net

Built for Milano Cortina 2026 — Winter Olympics AI Hackathon

OlympusOS is a cognitive operating system for cities — an AI orchestration platform built to solve one of the most underestimated risks in modern urban infrastructure: the systemic failure of human coordination during high-density events.

Traditional monitoring systems are passive. They display data. They do not reason across it, issue coordinated decisions, or adapt in real time to cascading crises. When 80,000 people exit a stadium simultaneously and the metro system fails, the gap between a dashboard and intelligence becomes a matter of public safety.

OlympusOS replaces that gap with seven specialized AI agents that perceive anomalies, forecast trajectories, deliberate on interventions, and execute coordinated responses — autonomously, in under 60 seconds.

Designed for Milano Cortina 2026, it represents a new category of urban infrastructure: Cognitive Urban Intelligence.

→ http://olympusos.ddns.net

No login required. Click ▶ RUN DEMO to launch the full 90-second cinematic crisis scenario over a photorealistic 3D rendering of San Siro Stadium, Milan. Watch seven AI agents detect a crowd crush in real time, deliberate, and resolve the incident — no injuries, response time 47 seconds.

OlympusOS was demonstrated using the Milano Cortina 2026 Winter Olympics as a scenario — not because it is limited to Olympic events, but because a mega-event represents the ultimate stress test for urban intelligence systems.

The real scope of OlympusOS is much broader:

• 🏙️ Smart city management — continuous AI coordination of urban systems
• 🚨 Crisis management — autonomous response to any large-scale emergency
• ⚡ Energy optimization — intelligent load balancing during peak demand
• 🚦 Traffic & mobility — city-wide flow optimization in real time
• 🌊 Disaster response — coordinated multi-agency AI orchestration
• 🏥 Public health emergencies — resource allocation and communication
• 🎭 Any high-density event — concerts, political summits, festivals

The Olympics scenario was chosen because it is immediate (Milano Cortina 2026 launches in months), globally recognized, and operationally extreme. It is the perfect proof-of-concept for a system designed to scale to any urban challenge.

Large-scale events expose fundamental fragility in urban systems:

• 📡 Fragmented monitoring — no single operator sees the full picture
• ⏱️ Reactive coordination — response arrives minutes after critical thresholds breach
• 🔗 Communication bottlenecks — transport, security, medical, and comms agencies operate in silos
• 📊 Dashboard paralysis — operators see data but receive no synthesis, prediction, or decision support
• 🌊 Cascade failure — one blocked gate triggers metro overcrowding triggers ambulance gridlock

The 2022 Itaewon crowd crush (158 deaths), the 2010 Love Parade disaster (21 deaths), and dozens of stadium incidents share a common thread: the information existed. The intelligence did not.

OlympusOS deploys a coordinated team of seven specialized AI agents, each with a defined cognitive role:

Agents communicate through a CrewAI pipeline with causal pacing: detection → forecast → deliberation → authorization → execution. The Orchestrator holds veto and override authority over all agents.

                        OlympusOS — Cognitive Layer
                        ===========================

  [Perception]   [Forecast]   [Mobility]   [Transit]
       |               |            |            |
  [Safety]       [Communications]  |            |
       |               |            |            |
       +---------------+------------+------------+
                                |
                         [Orchestrator]
                         Command Core
                                |
       +------------------------+------------------------+
       |                        |                        |
  [CesiumJS]            [FastAPI Backend]         [Speechmatics]
  3D Digital Twin       WebSocket / REST          Live Transcript
  Google 3D Tiles       CrewAI Pipeline           Audio Analysis
       |                        |                        |
       +------------------------+------------------------+
                                |
                     [Vultr Ubuntu 24.04]
                     nginx --> systemd
                     http://olympusos.ddns.net

  DETECT (0-12s)
  Perception detects density spike at Gate 4
       --> Camera 7 confirms visual bottleneck
       --> Forecast models 6.4 ppl/m2 in 3:40

  DELIBERATE (12-30s)
  Mobility identifies Corridor B as clear
       --> Safety stages medical teams
       --> Transit holds 30 buses at Lampugnano
       --> Orchestrator: AUTHORIZE

  EXECUTE (30-66s)
  Corridor B opens  -->  Gate 4 outflow redirects
  30 buses deploy   -->  M5 fails, buses become critical
  Ambulances roll   -->  Comms pushes bilingual alert

  RESOLVE (66-90s)
  Density: 6.4 --> 2.6 ppl/m2
  Risk: 0.83 --> 0.28
  Response window: 47 seconds. No injuries.

Python 3.11+
SUMO 1.18        # sudo apt install sumo
nginx
git

git clone https://github.com/NevineAKF/OlympusOS
cd OlympusOS

cp .env.example .env

GOOGLE_MAPS_API_KEY=your_google_maps_platform_key
CESIUM_ION_TOKEN=your_cesium_ion_token
SPEECHMATICS_API_KEY=your_speechmatics_key
FEATHERLESS_API_KEY=your_featherless_key
GEMINI_API_KEY=your_gemini_key

pip install -r requirements.txt

uvicorn backend.main:app --host 0.0.0.0 --port 8000

server {
    listen 80;

    location / {
        root /var/www/olympusos/dashboard;
        index index.html;
    }

    location /ws {
        proxy_pass http://localhost:8000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "Upgrade";
    }

    location /run_demo {
        proxy_pass http://localhost:8000;
    }
}

KEY=$(grep -oP 'GOOGLE_MAPS_API_KEY\s*=\s*\K\S+' .env)
ION=$(grep -oP 'CESIUM_ION_TOKEN\s*=\s*\K\S+' .env)
sed -i "s|__GOOGLE_MAPS_API_KEY__|${KEY}|g; s|__CESIUM_ION_TOKEN__|${ION}|g" dashboard/index.html

Navigate to http://your-server-ip/ and click ▶ RUN DEMO.

• 🎥 CCTV ingestion with real-time YOLO crowd density detection
• 📡 IoT pressure sensor grid at stadium gates
• 🚗 Live SUMO traffic simulation with real road state feeds
• 🗺️ Dynamic map overlays from real sensor data

• 🧬 Reinforcement learning policy optimization for crowd routing
• 🗂️ Vector database agent memory — persistent reasoning across events
• 🌍 Multilingual command interface (Italian, English, French, German)
• 🚁 Drone coordination API for aerial crowd monitoring
• 📈 Predictive modeling with 10-minute lookahead horizons

• 🚔 Integration with Italian police dispatch systems
• 🚑 Real-time ambulance and fire brigade coordination API
• 🚦 Smart traffic signal control interface
• 🛰️ Satellite crowd density feeds for stadium perimeter
• 🏛️ Government compliance and audit logging layer

• 🌐 Multi-city deployment framework
• 🤖 Autonomous emergency coordination — zero human approval latency
• 🏙️ Digital twin integration for full urban system modeling
• 🏅 Government API for Olympics, World Cup, and G7-scale events
• 📊 Federated learning across event venues globally

This is a proof-of-concept built by a solo developer over 3 days:

The architecture demonstrates systems-level thinking for a platform that, at full scale, would require dedicated engineering teams, institutional partnerships, and government-grade infrastructure.

Cities are the most complex adaptive systems humanity has ever built. And yet, when they fail — when 80,000 people try to leave a stadium at once, when a metro line drops, when a bottleneck turns into a crush — the systems designed to protect people are still running on radio calls, spreadsheets, and fragmented dashboards.

OlympusOS is the answer to that gap.

Not a smarter dashboard. Not a better alert system. A cognitive layer — a system that sees, reasons, decides, and acts. One that treats a city's real-time sensor data as a language and speaks back in coordinated action. One that compresses a 20-minute human coordination cycle into 47 seconds of autonomous intervention.

The prototype proves the architecture. The crisis at San Siro — 6.4 people per square metre, children near the railings, a metro line down, 47,000 app notifications pushed in the same second — all of it resolved, no injuries, under a minute.

This is what it looks like when cities stop reacting and start thinking.

OlympusOS. Cities that think.

Built for Milano Cortina 2026 — Winter Olympics AI Hackathon

🔴 http://olympusos.ddns.net — Live Demo