AWS Builder Center

Builder Center

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

AIdeas: 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

App Category

Social Impact

A Personal Tragedy and a Universal Blind Spot

We 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.
I studied entrepreneurship in university. 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. It sounds absurd, almost comical, but it's deeply heartbreaking. They were risking their lives because they refused to watch centuries-old forests burn. They wanted to do something.
But bravery shouldn't require blinding oneself in smoke. I realized that the core problem in firefighting isn't a lack of courage; it's a lack of time and a lack of vision.

My Vision

Firefighters and emergency responders operate in some of the most dangerous environments imaginable. During a building fire or wildfire, responders often have little to no visibility, limited information about victims, and must make rapid decisions under extreme pressure.
My vision was to build a system that gives first responders intelligent eyes in the sky before they even enter the danger zone.
Caligo Dynamics is an AI-powered autonomous drone swarm system designed to operate in smoke-filled or hazardous environments where traditional visibility is impossible.
The system deploys multiple drones equipped with LiDAR sensors, thermal cameras, and AI reasoning systems to detect fires, map environments, locate trapped civilians, and guide firefighters with real-time intelligence.
Instead of firefighters entering buildings blindly, the drones scout ahead and provide a complete situational map.
The system consists of four core layers:
• Autonomous drones operating with ROS2 and PX4
• AI reasoning powered by Amazon Bedrock
• AWS cloud infrastructure for processing and monitoring
• A real-time command dashboard for emergency responders

The drones act as an intelligent swarm, coordinating with each other to scan buildings, detect heat signatures, and analyze hazards.

Why This Matters: The 360-Degree Blind Spot

To truly understand the problem, I went straight to the source. Just yesterday, I stood in a Seattle Fire Department and spoke with Julien, a hero with 22 years of experience. What he told me shattered my perception of modern emergency response.
"Whoever arrives first needs to make an IRR (Initial Radio Report)," Julien explained. "We must dispatch everyone before knowing if it's a false alarm. To figure out if occupants are inside, we rely on phone reports, looking for people hanging from windows, or physically searching when we arrive. We have to do a 360 to see the back side... 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."

The Problem is Real and Deadly

Every year, firefighters die in zero-visibility conditions. According to the National Fire Protection Association:
  • 60-80 firefighters die annually in the United States alone
  • Zero visibility is a contributing factor in 40% of firefighter fatalities
  • Response time is critical - every minute counts when lives are at stake
  • Traditional drones fail in smoke, fog, and darkness
The Impact
Caligo Dynamics addresses this life-or-death challenge by providing:
  1. Situational Awareness - Drones equipped with thermal and LiDAR sensors can "see" through smoke and darkness, providing real-time intelligence to ground teams
  2. Rapid Deployment - Strategic pod placement across cities enables <45 second deployment to any incident location
  3. AI-Powered Decision Making - Amazon Bedrock analyzes sensor data in real-time, identifying trapped civilians, optimal evacuation routes, and fire suppression priorities
  4. Coordinated Response - Multi-drone swarms work together, covering more ground and providing redundancy if one unit fails
  5. Real Wildfire Integration - NASA FIRMS satellite data provides real-time wildfire detection across the USA, enabling proactive deployment
Social Impact
This isn't just about technology - it's about saving lives:
  • 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
  • Communities benefit from faster, more effective emergency response
  • Wildfire response teams get early detection and real-time fire tracking
The system is designed to be deployed in urban fire departments, wildfire response teams, and disaster relief organizations worldwide.
The reality is staggering: First responders are forced to make life-or-death decisions in the dark.

How I built this

Technical Architecture
The system uses a four-layer architecture that separates concerns while enabling real-time communication:
1
2
3
4
5
6
7
LAYER 4: Command Dashboard (Next.js 15 + React + Leaflet) │
│ - Real-time tactical map with drone positions │
│ - NASA FIRMS wildfire data integration │
│ - Click-to-deploy interface │
│ - AI feed with Bedrock recommendations │
│ - Live metrics and fleet management │
│ → Polls Flask bridge every 2 seconds
↕ HTTP/WebSocket
1
2
3
4
5
6
│ LAYER 3: Cloud Integration (AWS Lambda + S3 + CloudWatch) │
│ - AWS Lambda: Decision logging and Bedrock API handler │
│ - Amazon S3: Stores all autonomy decisions as JSON logs │
│ - CloudWatch: Real-time metrics (SeverityLevel, Confidence)│
│ - CloudTrail: Security and compliance logging │
│ → Serverless, scales automatically
↕ HTTP/REST API
1
2
3
4
5
│ LAYER 2: AI Brain (Flask + Amazon Bedrock + ROS2 Bridge) │
│ - caligo_server.py: Flask API server │
│ - Amazon Bedrock integration (Claude 3 Haiku) │
│ - ros2_bridge.py: Reads ROS2 topics → POSTs to Flask │
│ - Endpoints: /api/status, /api/bedrock, /api/firms |
↕ ROS2 Topics
1
2
3
4
5
6
│ LAYER 1: AWS Kiro Autonomy (ROS 2 + Bedrock Integration) │
│ - bedrock_autonomy.py: Kiro + Bedrock ROS 2 node │
│ - Real-time sensor data → AI decisions │
│ - Decision types: PROCEED, HOVER, RETREAT, EVACUATE │
│ - Severity levels: LOW, MEDIUM, HIGH, CRITICAL │
│ - Confidence scores: 0.0-1.0 with reasoning |
↕ ROS2 Topics
1
2
3
4
5
6
│ LAYER 0: Drone Simulation (PX4 + Gazebo + ROS 2 Humble) │
│ - 3 autonomous drones with PX4 autopilot │
│ - Gazebo Fortress physics simulation │
│ - Sensor suite: LiDAR, thermal, visibility │
│ - Obstacle detection and avoidance │
│ - Fire/thermal hazard detection |
Key Technologies
Robotics & Simulation:
  • ROS 2 Humble - Robot Operating System for sensor fusion and control
  • Gazebo Fortress - Physics-based 3D simulation environment
  • PX4 Autopilot - Industry-standard drone flight controller
  • Custom ROS2 packages - caligo_sensors, caligo_autonomy, caligo_sim
AI & Cloud:
  • Amazon Bedrock - Claude 3 Haiku for tactical decision-making
  • AWS Lambda - Serverless Bedrock API handler and decision logging
  • Amazon S3 - Incident log storage and decision archives
  • Amazon CloudWatch - System metrics and monitoring
  • NASA FIRMS API - Real-time wildfire satellite data
  • AWS Kiro Integration - ROS 2 + Bedrock autonomy decision layer
Frontend & Dashboard:
  • Next.js 15 - React framework with App Router
  • TypeScript - Type-safe development
  • Leaflet - Interactive mapping library
  • Tailwind CSS - Utility-first styling
  • shadcn/ui - Component library
Backend:
  • Flask - Python web framework for bridge server
  • Python 3.10+ - Core language for AI integration
  • WebSocket - Real-time bidirectional communication
Development Milestones
Phase 1: Foundation (Weeks 1-2)
  • Set up Ubuntu 22.04 development environment
  • Installed ROS 2 Humble and Gazebo Fortress
  • Created basic drone model with PX4 integration
  • Established project structure and build system
Phase 2: Sensor Integration (Weeks 3-4)
  • Implemented LiDAR obstacle detection
  • Added thermal imaging for fire detection
  • Created visibility sensor for smoke/fog simulation
  • Built sensor fusion node to combine all data streams
Phase 3: Autonomy & AI (Week 5)
  • Integrated Amazon Bedrock for decision-making
  • Developed obstacle avoidance algorithms
  • Created autonomous navigation system
  • Implemented multi-drone coordination
Phase 4: Dashboard Development (Weeks 7-8)
  • Built Next.js + Bedrock command center interface
  • Integrated Leaflet for interactive mapping
  • Created real-time data visualization
  • Added click-to-deploy functionality
Phase 5: Real Data Integration (Week 9)
  • Integrated drone simulation with dashboard
  • Connected ROS2 telemetry to backend
  • Linked AI decisions to interface
  • Unified deployment commands across system
  • Synchronized real-time drone telemetry streams
  • Integrated wildfire data with dashboard
Phase 6: Polish & Testing (Week 9)
  • Improved dashboard responsiveness and stability
  • Optimized real-time telemetry data updates
  • Fixed system integration and UI bugs
  • Tested autonomous drone deployment scenarios
  • Validated AI decision outputs accuracy
  • Conducted end-to-end system testing

Demo

System Overview
The Caligo Dynamics command center provides a comprehensive view of all drone operations:
Caligo Dynamics command center showing drone fleet status and AI tactical command feed generated by Amazon Bedrock
Drone fleet status panel showing thermal readings, radar activity, and battery levels
This map shows the drone location on the map
Real wildfire data across the United States from NASA FIRMS satellite system and Detailed fire incident data retrieved from satellite monitoring. this is the Zoom out view, of the previous picture of map to show all Active fires all over the state.
In this image, i placed one red wall and blue wall as you can see through camera feed and through bedrock it is detecting a corridor to its right with its coordinates, although its not fully complete yet but it shows that our AI Autonomy brain is working.

What I Learned

Technical Insights
1. Multi-Layer Architecture is Essential
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
  • Scale different parts based on load (e.g., multiple dashboard instances)
  • Debug issues in isolation
The ros2_bridge.py was a game-changer - it decoupled ROS2 from the web stack entirely.
2. Real-Time Systems Require Careful State Management
Managing state across three layers with different update frequencies was challenging:
  • ROS2 publishes at 10-50 Hz
  • Flask polls ROS2 at 2 Hz
  • Dashboard polls Flask at 0.5 Hz
I learned to use refs in React to avoid stale closures, implement proper cleanup in useEffect hooks, and handle race conditions when multiple async operations update the same state.
3. AI Integration Needs Fallbacks
Amazon Bedrock is powerful, but network latency and API limits are real. Key learnings:
  • Always implement intelligent fallbacks for critical operations
  • Cache common AI responses locally
  • Use streaming when possible to reduce perceived latency
  • Provide immediate feedback even if sometimes AI response takes seconds
The fallback AI I built actually handles 40% of scenarios without Bedrock, saving costs and improving response time.
4. Real Data is Messy
Integrating NASA FIRMS taught me to train our real world model and real-world data which requires extensive filtering:
  • 23,000+ fires globally, but only ~200 relevant to USA operations
  • Confidence levels vary - need to filter low-confidence detections
  • Coordinate precision varies by satellite
  • Data updates every 10 minutes, not real-time
I learned to always validate, filter, and sanitize external data before rendering.
5. User Experience Matters in Emergency Systems
This isn't a consumer app, it's a life-safety system. Every design decision considered:
  • Clarity over beauty - High contrast colors, large fonts, clear labels
  • Speed over features - One click deployment, no confirmation dialogs
  • Feedback is critical - Every action shows immediate visual response
  • Error states must be obvious - Red warnings, yellow cautions, clear messages
Development Journey Insights
1. Start with the Hard Parts
I initially wanted to build the pretty dashboard first. Big mistake. I learned to tackle the hardest technical challenges early:
  • ROS2 + Gazebo integration (Week 1)
  • Sensor fusion algorithms (Week 3)
  • Amazon Bedrock integration (Week 5)
By the time I got to the dashboard, the hard problems were solved and I could focus on UX.
2. Incremental Testing is Non-Negotiable
With three layers and dozens of components, end-to-end testing was impossible early on. I learned to:
  • Test each ROS2 node in isolation with ros2 topic echo
  • Mock the Flask API responses for dashboard development
  • Use Postman to test API endpoints independently
  • Build comprehensive logging at every layer
This saved countless hours of debugging "which layer is broken?"
3. Documentation as You Go
I created milestone documentation (M1-M9) as I completed each phase. This was invaluable when:
  • Returning to code after a break
  • Debugging issues days later
Future me thanks past me for those README files.
4. AWS Services are Powerful but Complex
Amazon Bedrock integration taught me:
  • IAM permissions are critical - get them right first
  • Bearer tokens expire - implement refresh logic
  • Cost monitoring is essential - Claude 3 Haiku was the right choice for cost/performance
I spent 1 day debugging IAM permissions before realizing I needed bedrock:InvokeModel not just bedrock:*.
5. Open Source Tools are Amazing
This project wouldn't exist without:
  • ROS2 - incredible robotics framework
  • Gazebo - professional-grade simulation
  • Next.js - best React framework
  • Leaflet - powerful mapping library
Standing on the shoulders of giants is real. I learned to contribute back by documenting issues and sharing solutions.
Personal Growth
1. Persistence Pays Off
There were moments I wanted to quit:
  • Week 2: Gazebo kept crashing
  • Week 4: Sensor fusion wasn't working
  • Week 6: Bedrock integration seemed impossible
  • Week 8: Dashboard state management was a mess
Each time, I took a break, researched the problem, and found a solution. The satisfaction of seeing it all work together was worth every frustrating hour.
2. Scope Management is a Skill
I had grand visions: 10 drones, VR interface, machine learning models, blockchain logging (yes, really). I learned to:
  • Focus on core functionality first
  • Add features incrementally
  • Cut ruthlessly when behind schedule
  • Save "nice to haves" for v2.0
The 3-drone system with solid core features beats a 10-drone system that barely works.
3. Community Matters
I learned so much from:
  • ROS2 documentation and forums
  • AWS documentation and samples
  • Stack Overflow answers
  • GitHub issues and discussions
  • YouTube tutorials
When stuck, I asked for help. When I figured something out, I documented it for others.
Conclusion
Caligo Dynamics represents more than just a technical achievement, it's a vision of how AI and robotics can save lives in the most dangerous situations. By combining Amazon Bedrock's intelligence with autonomous drone technology and real-time wildfire data, we've created a system that gives first responders superhuman capabilities in zero visibility conditions.
The journey from concept to working prototype taught me invaluable lessons about system architecture, AI integration, real-time systems, and the importance of user experience in critical applications. Every line of code was written with one goal in mind: helping firefighters and emergency responders do their jobs more safely and effectively.
This is just the beginning. With continued development and real-world testing, Caligo Dynamics has the potential to become a standard tool in emergency response operations worldwide, saving countless lives and protecting the brave men and women who run toward danger when others run away.
The future of emergency response is autonomous, intelligent, and ready to deploy.
Built with ❤️ for firefighters and first responders everywhere.
# aideas-2025# amazon-bedrock# social-impact# kiro# NAMER
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article