EvacuAI

Real-time wildfire detection and AI-powered evacuation routing, using NASA satellite data and Jac agents to save lives .

Comment

Inspiration

Natural disasters such as wildfires and floods create rapidly changing environments where evacuation decisions become difficult and time-sensitive. Existing systems are often centralized and depend heavily on manual coordination, which can slow down emergency response during critical moments.

I wanted to explore how autonomous AI agents and graph-based reasoning could automate evacuation coordination in real time.

The main question behind EvacuAI was:

What if AI agents could continuously monitor disasters, reason over geographic networks, and coordinate evacuation decisions without waiting for human input?

This inspired me to build a real-time multi-agent evacuation coordination platform powered by Jac walkers and autonomous decision loops.

What it does

EvacuAI simulates a disaster scenario where autonomous agents continuously:

  • monitor fire spread
  • evaluate risk levels
  • classify safe and unsafe evacuation zones
  • generate emergency alerts
  • visualize evacuation conditions on a live map

The system combines:

  • Jac for graph traversal and reasoning
  • Python + Flask for backend simulation
  • Leaflet.js for live map visualization

The simulation dynamically updates every few seconds and continuously adapts evacuation decisions based on changing disaster conditions.

How I built it

I built EvacuAI using a combination of Jac, Python, Flask, and Leaflet.js.

Disaster Simulation

A Python-based autonomous loop continuously simulates:

  • fire spread
  • changing danger zones
  • emergency escalation
  • evacuation conditions

The risk model evolves dynamically over time:

$$ Risk(t+1) = Risk(t) + \Delta FireSpread $$

Jac-Based Reasoning

Using Jac, I modeled locations as graph nodes connected through roads and evacuation paths.

node Location {
    has name: str;
    has risk: int = 0;
}

Jac walkers traverse the graph and evaluate evacuation safety dynamically.

if here.risk >= 7 {
    report here.name + " → BLOCKED";
}

Frontend Visualization

Using Leaflet.js, I built an interactive map that displays:

  • danger zones
  • evacuation alerts
  • real-time updates
  • evacuation routes

The frontend continuously fetches live state updates from the Flask backend.

Challenges I ran into

One of the biggest challenges was integrating:

  • Python simulation loops
  • Jac execution
  • frontend rendering
  • real-time backend updates

I also had to learn Jac syntax and graph-oriented architecture while simultaneously building a multi-agent system under hackathon time constraints.

Another challenge was synchronizing:

  • backend state
  • agent decisions
  • frontend visualization

without causing crashes or inconsistent updates.

Accomplishments that I'm proud of

I am proud that I successfully built:

  • a real-time autonomous disaster simulation
  • a graph-based evacuation reasoning system using Jac
  • a live interactive evacuation map
  • a continuously updating multi-agent system

I also successfully demonstrated:

  • autonomous agent behavior
  • graph traversal with Jac walkers
  • real-time evacuation coordination
  • dynamic emergency alert generation

Most importantly, I built a project that goes beyond a simple chatbot and demonstrates a real-world application of agentic AI.

What I learned

Through this project I learned:

  • how agentic AI systems differ from traditional API-driven applications
  • how graph traversal naturally models geographic infrastructure
  • how autonomous loops create continuously reasoning systems
  • how Jac walkers can support spatial AI reasoning

I also gained hands-on experience with:

  • Flask APIs
  • asynchronous simulation loops
  • real-time frontend visualization
  • Jac-based autonomous reasoning

What's next for EvacuAI

In future versions I would like to add:

  • real GIS and map APIs
  • traffic-aware evacuation routing
  • citizen movement simulation
  • hospital and vulnerable population prioritization
  • flood and earthquake support
  • distributed multi-agent coordination

My long-term goal is to explore how graph-native autonomous systems could eventually support:

  • disaster response agencies
  • smart city infrastructure
  • humanitarian evacuation planning
  • emergency coordination systems

Built With

Share this project:

Updates