MAAS- Multi-Disaster_Autonomous_Aerial_Swarm

Inspiration

Natural disasters like wildfires, floods, and search-and-rescue operations require immediate aerial intelligence. However, relying on cloud-based processing during disasters is dangerous—connectivity drops, latency spikes, and central servers fail. Furthermore, unauthorized access to disaster drones presents a massive security risk. We were inspired to build a fully decentralized, zero-trust autonomous drone swarm that processes everything on the edge and operates reliably even when the world is falling apart.

What it does

MAAS (Multi-Disaster Autonomous Aerial Swarm) is a complete ecosystem for deploying and managing autonomous drone swarms for disaster relief.

Zero-Trust Provisioning: Operators must pair with drones using a secure, time-sensitive 6-digit handshake through a local Edge Middleware.
Real-Time Edge AI: Drones stream telemetry and video via WebRTC. The video is processed locally by YOLOv10 for object detection (fires, floods, and survivors).
LLM Commander: An edge-deployed Phi-3 Mini multimodal LLM analyzes the YOLO detections and telemetry to autonomously make navigation decisions (e.g., commanding the drone to fly toward a detected fire) without human intervention.
VOD Analysis: A Video-On-Demand pipeline for post-mission debriefings, instantly summarizing footage and extracting geospatial intelligence.

How we built it

The architecture is split into 4 distinct micro-repositories, representing a true distributed system:

Frontend Command Center: Built with Next.js, React, and Tailwind CSS. It acts as the operator's dashboard, displaying live WebRTC video feeds and telemetry.
Go Backend Orchestrator: A high-performance Golang backend handling the Zero-Trust handshake and maintaining state.
Go Edge Middleware: A daemon running on the drone (or simulated drone) that generates the pairing codes and bridges MAVLink telemetry to the Orchestrator.
Python LLM & Vision Pipeline: We use ArduPilot SITL to simulate the drone. The computer vision runs YOLOv10 natively. We integrated a local Phi-3 LLM to act as the autonomous commander, parsing YOLO logs and sending MAVLink navigation commands back to the drone dynamically.

Challenges we ran into

WebRTC Latency & Streams: Bridging LiveKit WebRTC with native Python OpenCV processing was incredibly tough. We had to manage asynchronous event loops and frame buffering to prevent queue overflows and memory leaks during live inference.
Zero-Trust Handshakes: Enforcing a strict pairing protocol meant the frontend, orchestrator, and edge middleware all had to be perfectly synchronized. Tracking down proxy rewrites and CORS policies tested our debugging skills.
Local LLM Speed: Running Phi-3 alongside YOLOv10 on edge hardware requires intense optimization. We had to carefully manage Python virtual environments to ensure the AI pipeline didn't bottleneck the live video feed.

Accomplishments that we're proud of

Successfully orchestrating a fully autonomous loop: Drone → WebRTC → YOLOv10 → Phi-3 LLM → MAVLink → Drone Navigation.
Building a highly polished, responsive frontend Command Center that looks and feels like a true military-grade dashboard.
Implementing a genuine Zero-Trust provisioning system from scratch instead of just hardcoding passwords.

What we learned

How to write robust asynchronous Python using asyncio and FastAPI for real-time video processing.
The intricacies of the LiveKit WebRTC protocol and how to extract raw video frames for AI analysis in real-time.
How to bridge simulated ArduPilot (SITL) environments with modern web stacks via MAVLink.

What's next for MAAS

Deploying the software onto physical companion computers (like Jetson Orin Nanos) strapped to real drones.
Expanding the Swarm logic so multiple drones can collaboratively map a disaster zone using swarm intelligence algorithms.
Adding thermal imaging support to the computer vision pipeline for night-time search and rescue.

Built With

ardupilot
css
fastapi
golang
livekit
mavlink
next.js
phi-3
python
react
tailwind
typescript
webrtc
yolov10

Submitted to

Arm Create: AI Optimization Challenge

Created by

As the core architect and full-stack engineer for MAAS, I single-handedly built and integrated the distributed, four-tier multi-agent architecture from the ground up:

1. AI & Computer Vision Pipeline (Python/Edge AI): I spent over half a month strictly curating a disaster response dataset (fires, floods, stranded survivors) and extensively training and fine-tuning a custom YOLOv10 model. I engineered the live_agent.py and web_ui.py pipelines to process real-time video on the edge, integrating a local Phi-3 multimodal LLM as an autonomous drone commander. I also solved critical asynchronous event-loop blocking, OOM (Out of Memory) crashes, and CPU starvation issues by implementing PyTorch thread limits, dynamic frame resizing, and asynchronous threading to ensure the LiveKit video streams ran without latency.

2. Zero-Trust Backend & Middleware (Golang): I designed and developed the high-performance Golang Orchestrator and Edge Middleware daemon. I implemented a secure, time-sensitive 6-digit handshake provisioning system for drone pairing to ensure zero-trust access during disaster scenarios, entirely replacing hardcoded credentials. I also handled bridging MAVLink telemetry from the drone directly into the orchestrator.

3. Command Center (Next.js/React): I built the frontend operator dashboard using Next.js and Tailwind CSS. I integrated the LiveKit WebRTC SDK to pull real-time, ultra-low latency video feeds from the drones and overlaid the YOLOv10 object detection bounding boxes dynamically using WebRTC DataChannels.

4. Drone Simulation Integration: I successfully bridged the software stack with ArduPilot SITL (Software In The Loop) to simulate real-world drone flights, ensuring the Phi-3 LLM could autonomously parse visual anomalies (like fires) and successfully issue MAVLink navigation waypoints back to the drone without human intervention.

Sohail kustagi
* Frontend UI & 3D Map: Built the Next.js/React command dashboard, styling the neon-glassmorphic UI and configuring Mapbox GL 3D vector extrusions with volumetric RAG risk overlays.
* Worker-Driven Telemetry: Developed telemetry.worker.ts and useTelemetryWorker.ts to process 20Hz MAVLink WebSocket streams off the main thread, keeping rendering at 60 FPS.
* LiveKit Video Grid: Built the multi-stream WebRTC video grid with token generation routes and dynamic anomaly highlights.
* State & Pairing Integration: Created Zustand stores and the animated 6-digit provisioning modal to communicate with the backend /v1/swarm/claim API.
* Build & Deployment: Resolved Turbopack compiler bugs, duplicate React imports, and deployed the production app to Vercel.

hafiza jakkli

Updates

Sohail kustagi started this project — Aug 14, 2026 03:01 PM EDT

Leave feedback in the comments!

Log in or sign up for Devpost to join the conversation.