Dashboard
Post Analysis
Workflow

Flareline

Public fire data → Nemotron multi-agent pipeline → progressive map + recommendations.

Team: Henry, Sahan, Sam, Naomi

Inspiration

During the LA Cascades Fires, people lost homes and were left with lasting trauma — including Henry’s best friend. That made the gap feel personal: incident commanders are flooded with satellite hotspots, perimeters, weather, terrain, and infrastructure, while crews (especially non-local mutual-aid units) struggle to coordinate on a fire that changes by the second.

We wanted a system that doesn’t just chat about a fire — it ingests live public data, reasons with specialist agents, and puts actionable geometry on a map so response can adapt as conditions shift.

What it does

Flareline is a wildfire tactical decision-support dashboard. You pick an active fire and it:

Ingests multi-source intel — NASA FIRMS hotspots, NIFC perimeters, InciWeb incidents, Open-Meteo weather/elevation, NWS alerts, OSM stations/hydrants/water/staging, Census communities, OSRM routes
Runs an eight-role NVIDIA Nemotron pipeline — Router → Wind / Fuel / Terrain / Community / Hydrology specialists → Judge → Decision
Streams results over SSE onto a MapLibre map — predicted 6h / 12h / 24h spread, flank-spaced deployment targets on the growth edge, station→edge routes, water/staging context, and a numbered tactical briefing

Core idea for judges: Nemotron is the pipeline, not a chatbot. Agents produce structured judgment; deterministic geometry draws the map so commanders get something safe and visual, not free-form text floating over acres.

How we built it

Frontend: Next.js (App Router) + React + MapLibre — fire picker, collapsible legend, agent status rail, analysis briefing, intel panel, obstacle/reroute mode
Backend: Next.js API routes — /api/map-data, /api/analyze (SSE), /api/intel, /api/obstacles, /api/eval
Agents: Shared Nemotron client against NVIDIA’s OpenAI-compatible NIM API; structured JSON + repair/retry; timeouts + circuit breaker → mock fallback for reliable demos
Geo stack: Predicted perimeter expansion (wind + terrain bias, water clip); deployments on the 6h predicted edge; OSRM for road routes
Team split: Henry — AI/LLM workflow; Sahan & Sam — data aggregation + API discovery; Naomi — UI/UX

Stack narrative in one line: public fire GIS → Nemotron multi-agent JSON pipeline → progressive MapLibre briefing.

Challenges we ran into

LLM reliability under demo pressure — NVIDIA calls can hang or return messy JSON; we added timeouts, repair/retry, a circuit breaker, and a Judge that can drop bad specialists and still finish
Routing that looked “smart” but was tactically wrong — nearest-point-on-ring piled stations on one flank; we switched to flank-spaced targets on the predicted growth edge and skipped stations already inside the burn
Huge / MultiPolygon NIFC perimeters — tight bboxes and sparse rings broke spread prediction; we envelope/densify so 6/12/24h rings still appear
Context window vs. map richness — OSM hydrants, staging, and routes overwhelm prompts, so agents get a short observation brief while the full tactical stack stays on the map
Serverless streaming — multi-agent + Overpass over SSE can run long; Vercel maxDuration and graceful degradation matter for a live hackathon demo

Accomplishments that we're proud of

Eight Nemotron roles in one live system — router, five specialists, judge, decision — visible as they stream
Separation of concerns judges care about — Nemotron decides; geometry executes (spread rings, edge deployments, OSRM routes)
A map commanders can actually read — current perimeter, predicted rings, stations, routes, water/hydrants/staging, communities, wind, obstacles
Demo resilience — mock fallback so the story never dies if the model flakes
Eval harness (/eval) for structured-output success, drops, and latency — not just a pretty UI

What we learned

Multi-agent systems need a supervisor and failure modes, not just more prompts
For emergency GIS, LLMs should extract and prioritize; polygons and routes should stay deterministic
Public wildfire APIs are powerful but messy — caching, fixtures, and bbox strategy are half the product
Progressive SSE UX sells the pipeline better than a single “done” spinner
Clear team ownership (agents / data / UI) let us ship a full vertical slice under hackathon time

What's next for Flareline

Stronger fuel/terrain inputs (e.g. richer vegetation / fuel-stress layers)
Multi-fire resource allocation across simultaneous incidents
Persistent obstacles and shared incident state (beyond in-memory serverless)
Deeper commander workflows — annotated briefings, exportable IAPs, offline-friendly map packs
Optional alerting / handoff layers once the tactical core is battle-tested (evac polygons are map-only today)
Hardening for production timeouts, auth, and longer-running agent runs on Vercel Pro / dedicated workers