AIdeas Finalist: Caligo Dynamics - AI Powered Autonomous Drone Swarm for Emergency Response

When a fire breaks out, firefighters often enter buildings blindly, unable to see victims, hazards, or even the way out. This project uses AI-powered drone swarms built with ROS2, PX4, Kiro, and Amazon Bedrock to detect fires, locate civilians, map dangerous environments, and help emergency teams contain fires before lives are lost.
Siva Abishikth Mylavarapu

AI Engineer | Autonomous Systems, Quant Analysis & Neural Decoding
Published Apr 13, 2026
Last modified Apr 15, 2026
App CategorySocial Impact
My VisionWe are living in an era where humanity is curing diseases, exploring space, and building artificial intelligence that can write code in seconds. Yet, despite all our technological leaps, when a fire breaks out, we are still losing lives in the most primal, terrifying way possible.
My faculty dean, Atakan Yalçın a brilliant mentor who shaped my vision and his family lost their lives in a tragic hotel fire in Bolu. It was a place I had stayed at over a dozen times. The distance from the fire station meant that by the time help arrived, it was too late. I couldn't stop thinking about how fast a fire consumes, and how utterly helpless we are in the face of it.
I saw this same helplessness during the recent wildfires. People were running toward raging infernos with 0.5-liter water bottles. Bravery shouldn't require blinding oneself in smoke. The core problem in firefighting isn't a lack of courage it's a lack of time and a lack of vision.
To truly understand the problem, I stood in a Seattle Fire Department and spoke with Julien, a hero with 22 years of experience.
"Even with thermal imaging, I can see fire and bodies, but I can't see trip hazards or holes in the floor. We search by maintaining contact with the wall because of no visibility. Smoke inhalation kills, and with poor visibility, we often can't tell the way out."
First responders are forced to make life-or-death decisions in the dark. Caligo Dynamics exists to change that.
Caligo Dynamics is an AI-powered autonomous drone swarm system for emergency response in zero-visibility environments. Caligo is Latin for mist, darkness, fog exactly the conditions where our system excels. Before a single firefighter steps through a burning doorway, autonomous drones have already been inside mapping the floor plan, locating trapped civilians, identifying fire temperature and handed the incident commander a complete tactical picture in under 45 seconds.
Why This MattersStatistic
Value
Source
Firefighter deaths per year (USA)
60–80
NFPA Annual Report
Fatalities attributed to zero visibility
40%
NFPA
Average response time to structure fire
7 min 18 sec
NFPA 1710 Standard
Cost of a single firefighter fatality
>$1,000,000
Benefits + legal + replacement
Caligo full system deployment cost
~$90,000
Hardware + 1 year AWS
ROI on one prevented fatality
11×
$1M saved / $90K deployment
The tools to solve this exist. The AI doesn't exists. The sensors exist. Nobody had built the system that puts them together for the people who need it most.
This is a Social Impact project because it directly addresses preventable death. Not firefighter death as an abstraction Julien's colleagues, people like Atakan's family, the civilians who die waiting for responders to find them in smoke-filled corridors. Every minute of blindness is a minute someone doesn't have. Caligo gives first responders intelligent eyes in the sky before they even enter the danger zone. Firefighters get critical intelligence before entering dangerous buildings. Trapped civilians are located faster using thermal imaging. Incident commanders make better decisions with real-time AI analysis. Wildfire response teams get early detection and real-time fire tracking. The system is designed for urban fire departments, wildfire response teams, and disaster relief organizations worldwide.
Competitive Landscape
Solution
Autonomous Swarm
AI Tactical Reasoning
Fire Suppression
Civilian Detection
Real-time SLAM
Natural Language Control
DJI Enterprise Dock 2
❌
❌
❌
❌
❌
❌
Skydio X10
❌
❌
❌
❌
✅
❌
Percepto Arc
❌
❌
❌
❌
❌
❌
Nightingale Security
❌
❌
❌
❌
❌
❌
Draganfly Emergency
✅
❌
❌
✅
❌
❌
Caligo Dynamics
✅
✅
✅
✅
✅
✅
DJI provides best-in-class hardware but zero autonomous intelligence a human pilot still makes every decision. Skydio leads in obstacle avoidance but is built for infrastructure inspection, not emergency response. None of these platforms let an incident commander type a natural language command and watch three drones execute it in formation. That's the gap Caligo fills.
﻿
How I Built ThisSystem Architecture
The system has four layers working together in real time:
plaintext
+==========================================================================================+
|                       CALIGO DYNAMICS — FULL SYSTEM ARCHITECTURE                        |
+==========================================================================================+
|                                                                                          |
|  +-----------------------------------------------------------------------------------+  |
|  |                   PRESENTATION LAYER  (Next.js 15 · TypeScript)                   |  |
|  +------------------+------------------+-------------------+------------------------+  |
|  |   CesiumMap      |  Webots3DMap     |     AIFeed        |      FleetPanel         |  |
|  |                  |                  |                   |                         |  |
|  | MapLibre GL      | Canvas 2D        | Bedrock chat      | DroneState cards        |  |
|  | 3D buildings     | Three.js GLB     | NL -> commands    | mode badges             |  |
|  | NASA FIRMS       | 100ms GPS poll   | history context   | commandedModesRef       |  |
|  | VIIRS fires      | formation lines  | prefill trick     | 30s mode lock           |  |
|  | GLB markers      | crown + pulse    | parseCommands()   | swarm leader crown      |  |
|  | click-to-deploy  | fire glow        | animateDroneTo()  | AI CMD badge            |  |
|  +------------------+------------------+-------------------+------------------------+  |
|        |                  |                   |                      |                  |
|    2s poll            100ms poll         POST /api/bedrock       1s poll               |
|    /api/status        :8765/telemetry    + history               /api/swarm            |
|        |                  |             + liveContext            /api/swarm_events     |
|        v                  v                   v                      v                  |
|                                                                                          |
|  +-----------------------------------------------------------------------------------+  |
|  |                   BRIDGE LAYER  (Flask · Python · port 5000)                      |  |
|  +-----------------------------------------------------------------------------------+  |
|                                                                                          |
|  |  /api/status        --> drone telemetry, fires, suppression%, civilians           |  |
|  |  /api/bedrock       --> proxy to AWS Bedrock + inject live telemetry              |  |
|  |  /api/swarm         --> GET/POST swarm state (active, leader, formation)          |  |
|  |  /api/swarm_event   --> Webots controller pushes phase transitions here           |  |
|  |  /api/swarm_events  --> dashboard polls, clears after read                        |  |
|  |  /api/deploy        --> stores pending_deploy for ROS2 bridge pickup              |  |
|  |  /api/deploy/pending--> ROS2 bridge polls this every 500ms                        |  |
|  |  /api/sim/update    --> ROS2 bridge POSTs real simulation data here               |  |
|  |  /api/weather       --> 5 presets with sensor degradation params                  |  |
|  |  /api/firms         --> proxies NASA FIRMS VIIRS satellite API                    |  |
|  |                                                                                   |  |
|  |  _sim_state{}       --> in-memory state (drones, fires, weather, swarm, pods)     |  |
|  |  _animate_state()   --> background thread: drains battery, moves drones           |  |
|  +-----------------------------------------------------------------------------------+  |
|           |                        |                           |                         |
|           v                        v                           v                         |
|                                                                                          |
|  +------------------+  +------------------------+  +------------------------------+     |
|  |   AWS BEDROCK    |  |      ROS2 BRIDGE        |  |        AWS CLOUD             |     |
|  |                  |  |   ros2_bridge.py         |  |                              |     |
|  | Claude 3.5 Haiku |  |                          |  | Lambda: decision-logger      |     |
|  | system prompt    |  | subscribes:              |  | S3: caligo-dynamics-logs     |     |
|  | + live telemetry |  |  /caligo/sensor_summary  |  |   decisions/{ts}.json        |     |
|  | + history        |  |  /caligo/autonomy_       |  | CloudWatch: CaligoDynamics   |     |
|  | + prefill        |  |    decision              |  |   SeverityLevel metric       |     |
|  |                  |  |  /caligo/fire_location   |  |   ConfidenceScore metric     |     |
|  | response parsed  |  |  /caligo/person_location |  | IAM: bedrock:InvokeModel     |     |
|  | by bedrock-      |  |                          |  |      s3:PutObject            |     |
|  | parser.ts        |  | publishes:               |  |      cloudwatch:PutMetric    |     |
|  +------------------+  |  /caligo/deploy_command  |  +------------------------------+     |
|                        +------------------------+                                        |
|                                    |                                                     |
|                              ROS2 topics                                                 |
|                                    v                                                     |
|                                                                                          |
|  +-----------------------------------------------------------------------------------+  |
|  |            KIRO AUTONOMY LAYER  (ROS2 Humble · 18+ nodes · 60+ topics)            |  |
|  +-----------------------------------------------------------------------------------+  |
|  |                                                                                   |  |
|  |  caligo_sensors/              caligo_autonomy/           caligo_msgs/ (7 types)   |  |
|  |  +---------------------+      +--------------------+     +--------------------+   |  |
|  |  | thermal_detector    |      | bedrock_autonomy   |     | SensorSummary      |   |  |
|  |  | person_detector     | ---> |   severity:        |     | AutonomyDecision   |   |  |
|  |  | obstacle_detector   |      |   LOW|MED|HIGH|CRIT|     | PodStatus          |   |  |
|  |  | sensor_fusion       |      |   action:          |     | FleetCommand       |   |  |
|  |  | slam_mapper         |      |   PROCEED|HOVER    |     | DroneStatus        |   |  |
|  |  | weather_simulator   |      |   RETREAT|EVACUATE |     | FireLocation       |   |  |
|  |  | particle_controller |      |   MARK_CIVILIANS   |     | PersonLocation     |   |  |
|  |  +---------------------+      |   confidence:0-1.0 |     +--------------------+   |  |
|  |                               +--------------------+                               |  |
|  |                                                                                   |  |
|  |  autonomous_controller.py                                                         |  |
|  |  +--------------------------------------------------------------------------+     |  |
|  |  | SEARCH --> APPROACH_FIRE --> SUPPRESS --> MARK                           |     |  |
|  |  | priority: civilians(1) > fire(2) > search(3)                            |     |  |
|  |  | learns fire_location from /caligo/fire_location  (no hardcoded coords)  |     |  |
|  |  | learns person_location from /caligo/person_location                     |     |  |
|  |  +--------------------------------------------------------------------------+     |  |
|  +-----------------------------------------------------------------------------------+  |
|                                    |                                                     |
|                               cmd_vel                                                    |
|                                    v                                                     |
|                                                                                          |
|  +-----------------------------------------------------------------------------------+  |
|  |         SIMULATION LAYER  (Webots R2025a · PX4 SITL · Python controllers)         |  |
|  +-----------------------------------------------------------------------------------+  |
|  |                                                                                   |  |
|  |  UNIT-01  caligo_camera.py  port 8765                                             |  |
|  |  +-----------------------------------------------------------------------+        |  |
|  |  | HTTP :8765   GET /telemetry  /snapshot  /camera                       |        |  |
|  |  |              POST /deploy  /pos                                        |        |  |
|  |  | Coord :8766  GET /target/2  /target/3  (formation targets)             |        |  |
|  |  | AI thread    swarm_brain() 500ms phase state machine                  |        |  |
|  |  | Phases: PATROL->FIRE_DETECTED->DEPLOYING->SUPPRESSING                 |        |  |
|  |  |         ->ESCALATED->AWAITING_SWARM->SWARM_DEPLOYED                   |        |  |
|  |  | Sensors: GPS  IMU  Gyro  Camera 640x480  LiDAR  Thermal               |        |  |
|  |  | PID:  KVT=68.5  KRP=50.0  KPP=30.0  KVP=3.0  KVO=0.6                |        |  |
|  |  | Avoidance: repulsion field  12m detect  6m hard stop                  |        |  |
|  |  +-----------------------------------------------------------------------+        |  |
|  |                                                                                   |  |
|  |  UNIT-02  drone2.py  port 8767      UNIT-03  drone3.py  port 8768                |  |
|  |  +------------------------------+   +------------------------------+              |  |
|  |  | polls :8766/target/2  500ms  |   | polls :8766/target/3  500ms  |              |  |
|  |  | swarm inactive -> hold ground|   | swarm inactive -> hold ground|              |  |
|  |  | swarm active -> fly formation|   | swarm active -> fly formation|              |  |
|  |  | POST :8765/pos every 500ms   |   | POST :8765/pos every 500ms   |              |  |
|  |  | MJPEG camera stream :8767    |   | MJPEG camera stream :8768    |              |  |
|  |  +------------------------------+   +------------------------------+              |  |
|  |                                                                                   |  |
|  |  World: Webots R2025a  400x400m  SmallManor  4x Windmill  Road  Forest           |  |
|  |  Fire:  DEF FIRE_SOURCE  PointLight intensity=12  Sphere radius=1.2              |  |
|  +-----------------------------------------------------------------------------------+  |
+==========================================================================================+
Dashboard: MapLibre GL 3D tactical map with NASA FIRMS live wildfire data, Webots simulation map at 100ms polling, AI feed with natural language commands, fleet panel with live drone telemetry
Flask Bridge: 10 API endpoints connecting dashboard, Bedrock, ROS2 bridge, and Webots controllers. Manages swarm state, weather presets, and deployment commands
Kiro Autonomy Layer: ROS2 Humble with 18+ nodes and 60+ topics. The  BedrockAutonomy  node calls Claude 3.5 Haiku with live sensor data and publishes decisions:  PROCEED | HOVER | RETREAT | EVACUATE | MARK_CIVILIANS  with severity level and confidence score. Every decision logs to AWS S3 and CloudWatch
Simulation Layer: Three physical drones in Webots R2025a, each with its own Python controller, camera stream, and GPS reporting. UNIT-01 runs the AI brain and swarm coordination server on port 8766. UNIT-02 and UNIT-03 poll for formation targets every 500ms
Development Milestones
Phase 1 - Foundation (Weeks 1–2): ROS2 Humble, Gazebo Fortress, PX4 SITL, colcon build system
Phase 2 - Sensor Integration (Weeks 3–4): LiDAR (360°, 30m), thermal imaging, visibility sensor,  sensor_fusion.py  combining all streams
Phase 3 - Autonomy & AI (Week 5): Amazon Bedrock integration, priority queue (civilians > fire > search), multi-drone coordination
Phase 4 - Dashboard (Weeks 7–8): Next.js 15 command center, MapLibre GL 3D mapping, real-time telemetry, click-to-deploy
Phase 5 - Real Data Integration (Week 9): ROS2 → Flask bridge, NASA FIRMS wildfire data, unified deployment pipeline
Phase 6 - Polish & Testing (Week 10): Mode-overwrite race condition fixed, end-to-end integration testing
Phase 7 - True Autonomy & Swarm (Post-competition): Sensor-driven learning (no hardcoded coordinates), <500ms touch-to-deploy, 3-drone physical swarm, 5-formation coordination, leader election, Obsidian knowledge graph (98 notes, 14 folders)
Key Technical Features
The AI Brain in Obsidian - one of the most distinctive aspects of this project is how the system's knowledge is organized. The entire architecture every component, every API endpoint, every data flow, every research paper, every regulation is mapped as an interconnected knowledge graph in Obsidian. 98 notes across 14 folders: Drones, AI, Swarm, Dashboard, Code, API, Ports, Sensors, Hardware, AWS, Infrastructure, Regulations, Research, Concepts. Every note links to every related note. The Boids algorithm that inspired the formation offsets links to the 1986 Reynolds paper, links to MDPI drone swarm firefighting research, links to the actual Python implementation in  swarm.ts . The FAA Part 107 note links to the BVLOS waiver, links to the 2025 DFR program, links to the deployment table in this article. It's not documentation it's a living system map. When a question comes up about how swarm coordination works, the answer is three clicks away with the code, the research it's based on, and the regulations it needs to comply with in production.
﻿
Swarm coordination - five formations with precise geometric offsets from the leader:
Formation
Use Case
UNIT-02
UNIT-03
V
Search / Advance
(-8, -8)
(8, -8)
SURROUND
Contain Fire
(-12, 0)
(12, 0)
LINE
Push Forward
(0, -10)
(0, -20)
DIAMOND
Protect Asset
(0, -10)
(0, +10)
TRAIL
Escort
(-6, -8)
(-12, -16)
Leader election runs every 500ms. UNIT-01 commands by default. Battery drops below 25% → command transfers automatically to the highest-battery drone. No human intervention required.
﻿
Deployment model:
Consideration
Detail
Regulatory framework
FAA Part 107 + BVLOS waiver
Emergency pathway
FAA Drone as First Responder (DFR) — first waiver issued 2025
Airspace management
Remote ID broadcasting + UTM coordination server
Pod placement
8 pods across NYC, 302 sq miles, NFPA 1710 4-min standard
Operational cost
~$200/month AWS infrastructure
Hardware cost
~$90,000 full deployment
Break-even
1 prevented fatality = 11× ROI
﻿
Demo
﻿
﻿
﻿
﻿
﻿
﻿
﻿
﻿
﻿
﻿
What I LearnedWhich judge feedback resonated most, and how did I improve the original idea?
Every suggestion the judges made was valid. Here is what I did to address each one.
On hardware: The simulation is the validation layer, not a shortcut. Every PID gain, every formation offset, every obstacle avoidance threshold is tuned before it goes on a physical aircraft. The Webots physics engine uses the actual DJI Mavic 2 Pro PROTO model with real flight dynamics. Parts are being sourced one by one. The next phase: NVIDIA Jetson for onboard inference, real thermal cameras and LiDAR, controlled field testing. When the hardware arrives, the software is ready.
On cost: One prevented firefighter fatality saves over $1,000,000. A full pod deployment costs ~$90,000 that's an 11× ROI on the first incident. Drone units run $3,000–$8,000. Deployment pods $10,000–$20,000. AWS infrastructure ~$200/month serverless. For comparison, aerial firefighting helicopters cost $3,000–$10,000 per hour to operate.
On scalability:
City Size
Pods
Coverage
Drones
Small (100k pop)
4–6
2–3 km radius
12–18
Medium (500k pop)
10–20
2–5 km radius
30–60
Large metro (2M+)
25–50
2–5 km radius
75–150
﻿
Pod placement is optimized using population density, historical fire incident data, and response time modeling against the NFPA 1710 4-minute standard. Multiple drones deploy simultaneously, swarm coordination distributes tasks, and redundancy ensures reliability if one unit fails.
On regulations: FAA Part 107 + BVLOS waiver. The 2025 DFR program specifically enables BVLOS for public safety agencies. Caligo's architecture fixed pod locations, pre-approved corridors, automatic Remote ID, swarm deconfliction via the coordination server aligns with this framework from day one.
On competition: DJI provides the best hardware but zero autonomous intelligence. Skydio leads in obstacle avoidance but is built for inspection, not emergency response. None combine autonomous swarm coordination, AI tactical reasoning, fire suppression, civilian detection, SLAM mapping, and natural language control in a single platform.
What key insights did you gain?
The deepest technical insight came from a distributed state bug. The Flask server was returning hardcoded drone modes every two seconds, silently overwriting every AI command the moment it was issued. The fix a  commandedModesRef  map that locks AI-commanded modes for 30 seconds, checked by every polling cycle before it writes is a microcosm of a much larger truth: in any distributed system, state ownership is everything. The question isn't "who can write this value?" It's "who made the last intentional decision about it?" Managing state across three layers with different update frequencies ROS2 at 10–50 Hz, Flask at 2 Hz, dashboard at 0.5 Hz forced a level of architectural discipline that changed how I think about every system I'll build after this.
The second insight is about multi-layer architecture. Building a robotics system taught me that separation of concerns isn't just good practice it's survival. By splitting the system into simulation, AI brain, and dashboard layers, I could develop and test each layer independently, replace components without breaking the whole system, and debug issues in isolation. The  ros2_bridge.py  was a game-changer it decoupled ROS2 from the web stack entirely. When the bridge is running, real simulation data flows. When it's not, the animated fallback keeps the dashboard alive for demos.
The third insight is about what AI actually enables. The first version of the Bedrock integration was transactional send query, get response. The final version maintains conversation history, injects live telemetry into every message, parses responses to extract and execute drone commands, uses a prefill technique to force conversational prose instead of bullet lists, and locks the resulting state changes against polling overwrites. The difference between a chatbot and an AI commander is context, consequence, and persistence. Building with Kiro made it possible to hold the entire system context simultaneously when a bug crossed four files and three layers, Kiro traced it end to end in minutes instead of hours. The entire swarm control system coordination server, follower controllers, formation geometry, dashboard integration, fleet panel badges, leader election was designed, implemented, debugged, and deployed in a single session.
I started this project because of a tragedy I couldn't stop thinking about. I'm finishing it because of a firefighter in Seattle who told me he navigates burning buildings by touching walls. Those two things the loss that started this and the conversation that clarified it are the reason every line of code in this system exists.
Caligo Dynamics, founded by Furkan Serhatlioglu and Siva Abishikth Mylavarapu, bridges human bravery with intelligent technology to transform emergency response.
Built with ❤️ for firefighters and first responders everywhere.
Statistic	Value	Source
Firefighter deaths per year (USA)	60–80	NFPA Annual Report
Fatalities attributed to zero visibility	40%	NFPA
Average response time to structure fire	7 min 18 sec	NFPA 1710 Standard
Cost of a single firefighter fatality	>$1,000,000	Benefits + legal + replacement
Caligo full system deployment cost	~$90,000	Hardware + 1 year AWS
ROI on one prevented fatality	11×	$1M saved / $90K deployment
Solution	Autonomous Swarm	AI Tactical Reasoning	Fire Suppression	Civilian Detection	Real-time SLAM	Natural Language Control
DJI Enterprise Dock 2	❌	❌	❌	❌	❌	❌
Skydio X10	❌	❌	❌	❌	✅	❌
Percepto Arc	❌	❌	❌	❌	❌	❌
Nightingale Security	❌	❌	❌	❌	❌	❌
Draganfly Emergency	✅	❌	❌	✅	❌	❌
Caligo Dynamics	✅	✅	✅	✅	✅	✅
Formation	Use Case	UNIT-02	UNIT-03
V	Search / Advance	(-8, -8)	(8, -8)
SURROUND	Contain Fire	(-12, 0)	(12, 0)
LINE	Push Forward	(0, -10)	(0, -20)
DIAMOND	Protect Asset	(0, -10)	(0, +10)
TRAIL	Escort	(-6, -8)	(-12, -16)
Consideration	Detail
Regulatory framework	FAA Part 107 + BVLOS waiver
Emergency pathway	FAA Drone as First Responder (DFR) — first waiver issued 2025
Airspace management	Remote ID broadcasting + UTM coordination server
Pod placement	8 pods across NYC, 302 sq miles, NFPA 1710 4-min standard
Operational cost	~$200/month AWS infrastructure
Hardware cost	~$90,000 full deployment
Break-even	1 prevented fatality = 11× ROI