Skip to content
Back to Projects

2026

Wildfire Watch: Smoke Detection and Response Swarm

  • Python
  • YOLOv8
  • MLflow
  • OpenCV
  • NVIDIA NIM
  • Shapely
  • Streamlit
  • Folium
  • SQLite
  • Docker
  • GitHub Actions

Wildfire Watch watches a fixed hilltop camera feed, or a recorded time-lapse from the HPWREN Fire Ignition images Library, and detects smoke plumes with a YOLOv8 detector. Each plume is tracked across frames and becomes exactly one versioned event, which is matched against a curated catalogue of historical CAL FIRE incidents. When the evidence is strong enough, it plans reconnaissance tasks for a small simulated swarm of agents, and a Streamlit and Folium dashboard shows the events, tasks, agents, fire perimeter and cameras on a map.

It keeps location honest. A bounding box is in image pixels and one camera cannot say where a fire is, so the system never turns a box into a latitude and longitude. It keeps four locations apart (the camera that saw the smoke, the detection in the frame, the matched historical incident and the agents' destination), and matching follows fixed rules that can be traced: a curated sequence mapping, or a camera within range and heading of an incident active at the time.

The language model, Llama 3 on NVIDIA NIM, only writes a plain-language summary of each assessment. It never sees coordinates, never picks a location and never confirms a fire; the assessment itself is rule-based. The agents route around the buffered fire perimeter, never through it, using A* on a graph with the exclusion zone removed, atomic task claims and a strict state machine, with a watchdog that recovers stalled or unsafe agents.

The smoke detector is trained in three commands. The AI For Mankind set of 2,192 labelled smoke images is converted to YOLO format, leaving out every image from the three demo fires' dates so they stay unseen, then YOLOv8 is trained with every run tracked in MLflow: settings, per-epoch losses, final precision, recall and mAP, image counts, the excluded dates, the git commit and the weights. Promoting a run copies its weights to where the app loads them and registers a new version in the MLflow model registry, so the model in use can always be traced back to the run, data and code that produced it. No trained weights ship with the project; until they exist, a ground-truth replay of the HPWREN boxes stands in, labelled as such everywhere so it is never mistaken for model output.

It grew out of Waste Swarm, an earlier fly-tipping detection and dispatch system for London, and keeps that project's architecture and reliability layer: schema-validated events, a dead-letter queue, retries and a circuit breaker with a deterministic fallback summary, SQLite state and an append-only incident ledger. Tests run fully offline, with no network, API key, dataset or model weights, and GitHub Actions lints, tests behind a coverage gate and builds a Docker image on every pull request.

Results & Highlights

  • One event per smoke plume, matched to historical incidents by deterministic, traceable rules rather than guessed coordinates
  • YOLOv8 smoke-detector training tracked in MLflow, with the demo fires held out and every promoted model traceable to its run
  • The language model writes summaries only: it never sees coordinates, picks a location or confirms a fire
  • Simulated agents route around the fire perimeter with A* and atomic task claims, watched by a recovery watchdog
  • Fully offline test suite behind an 85% coverage gate, with CI/CD building and publishing a Docker image

Challenges

The original Waste Swarm turned each detection into a dispatch to a point on a map, but a single camera's bounding box says nothing about where a fire actually is. Rather than invent a position, the redesign separates the camera's location, the detection, the matched historical incident and the agents' destination, and sends agents only to observation points computed outside the fire's buffered perimeter.

What I Learned

That an LLM is safest kept out of the decision path: letting fixed rules decide and the model only explain makes every outcome traceable and lets the whole system run, and be tested, without it.