Human-in-the-loop emergency dispatch support for wildfire surge events.

Four AI agents work silently behind a 911 dispatcher — classifying calls, dispatching units, and generating voice briefings — so the dispatcher stays in control even when the phones don't stop ringing.

Core principle: The AI never speaks to callers. The dispatcher is always the human interface.

Built at HackDavis 2026.

During a major wildfire, a single 911 dispatch center can receive dozens of calls per minute. A human dispatcher can handle one caller at a time. The backlog grows. Triage decisions get made under pressure with incomplete information. Heavy assets get deployed incorrectly.

Clear Dispatch keeps the dispatcher in control while AI handles the coordination layer.

Clear Dispatch operates in one of two modes, switching automatically based on call volume:

Assisted Mode — Tesla Autopilot The dispatcher handles calls normally. AI agents run in the background: classifying severity, finding the nearest available unit, and preparing a voice briefing — but the dispatcher owns every decision.

Surge Mode — Waymo When call rate exceeds the threshold (default: 10 calls/min), agents take over triage and routing automatically. The dispatcher monitors the queue, approves heavy asset dispatches, and can override back to Assisted at any time.

The system transitions back to Assisted Mode after 120 continuous seconds below the surge threshold.

All four agents broadcast status updates in real time, so the dispatcher sees exactly what each agent is doing at every step.

Requirements: Python 3.11+, uv, Node.js 18+, Anthropic API key

cd signal/backend
cp .env.example .env       # fill in ANTHROPIC_API_KEY (required)
uv sync
uvicorn main:app --reload --port 8000

Verify: curl http://localhost:8000/health → {"status":"ok","mode":"ASSISTED"}

cd signal/frontend
npm install
npm run dev                 # → http://localhost:5173

signal/backend/.env

signal/frontend/.env (create if missing)

VITE_WS_URL=ws://localhost:8000/ws

With both services running, follow this sequence:

Pause stops all API spend instantly (simulator off, pipeline blocked). Resume restores it.

signal/
├── backend/                FastAPI + Python 3.11 (uv-managed)
│   ├── main.py             Entry point — lifespan, CORS, WebSocket, /audio static mount
│   ├── state.py            Single in-memory source of truth (never define state elsewhere)
│   ├── logger.py           In-memory log ring buffer (500 entries); redacts API keys
│   ├── simulator.py        Poisson call generator — rate driven by state.simulator_lambda
│   ├── agents/
│   │   ├── monitor.py      Background loop: sliding window → mode transitions
│   │   ├── triage.py       Claude Haiku → severity · incident_type · vulnerable
│   │   ├── resource.py     Haversine nearest unit · Protocol HOLD for heavy assets
│   │   └── relay.py        Claude Haiku → briefing text · ElevenLabs TTS → audio/{id}.mp3
│   ├── routers/            calls · state · override · hold · demo · logs · live_calls · surge_calls
│   ├── ws/hub.py           ConnectionManager — all WS events go through manager.broadcast()
│   └── data/               park_fire.geojson · resources.json · vulnerability.json · transcripts/
└── frontend/               React 18 + Vite + Tailwind CSS
    └── src/
        ├── types.ts              All TypeScript types (Mode, Severity, WsMessage, AppState…)
        ├── store/reducer.ts      Pure reducer — every WebSocket message type handled here
        ├── hooks/useWebSocket.ts Auto-reconnecting hook (3s retry, StrictMode-safe)
        └── components/           ModeIndicator · CallQueue · AgentCards · MapView ·
                                  BriefingPanel · HoldModal · OverrideButton · AuditTrail ·
                                  DemoControls · SosQrCode · VoiceAgentModal

POST /call
  → CALL_ADDED (PENDING broadcast)
  → TRIAGE  (Claude Haiku)  → severity · incident_type · vulnerable flag
  → CALL_ADDED (real severity broadcast)
  → RESOURCE                → nearest unit via Haversine  (ETA = km ÷ 80 × 60 min)
      heavy asset?  → HOLD_REQUIRED  → polls every 2s, max 60s, for dispatcher confirm
      standard?     → UNIT_DISPATCHED immediately
  → RELAY   (Claude Haiku)  → briefing text → ElevenLabs TTS → audio/{id}.mp3
  → BRIEFING_READY + INCIDENT_REPORT broadcast

Backend ──WebSocket──► reducer.ts ──► useReducer ──► React UI
         JSON events    (pure fn)       (state)

Every UI update originates from a WebSocket event broadcast via ws/hub.py. There is no polling from the frontend.

Two long-running tasks are spawned at startup and cancelled on shutdown:

• monitor_loop() — runs every 5 seconds; computes call rate over a sliding 60-second window; triggers ASSISTED→SURGE when rate exceeds surge_threshold; reverts SURGE→ASSISTED after 120 continuous seconds below threshold.

• simulator_loop() — generates calls at exponential inter-arrival times parameterized by state.simulator_lambda["value"] (default 2.0 calls/min; demo surge sets 15.0). Skips when state.system_state["paused"] is True.

When the RESOURCE agent selects a heavy asset (air_tanker, heavy_rescue, hazmat), it does not dispatch immediately. Instead:

1. A HOLD_REQUIRED event is broadcast — the frontend shows a blocking modal
2. The backend polls state.hold_queue every 2 seconds for up to 60 seconds
3. If the dispatcher clicks Confirm → the asset is dispatched
4. If the dispatcher clicks Cancel, or the 60s window expires → the asset is returned to the pool and the call proceeds without it

This enforces CAL FIRE protocol §4.2 requirements for heavy asset authorization.

In Surge Mode, a QR code appears in the top-right corner of the dispatcher screen. A judge scans it with their phone, speaks directly to the ElevenLabs voice agent, and appears as a live incoming call — complete with GPS coordinates.

• Laptop and phone on the same Wi-Fi network
• Android + Chrome (iOS Safari blocks microphone access over plain HTTP)
• ELEVENLABS_API_KEY set in signal/backend/.env

# 1. Find your LAN IP address
ipconfig getifaddr en0   # macOS   → e.g. 192.168.1.42
ip route get 1 | awk '{print $7; exit}'   # Linux

# 2. Start the backend (unchanged)
cd signal/backend && uvicorn main:app --reload --port 8000

# 3. Start the frontend (Vite binds to 0.0.0.0 — accessible on LAN)
cd signal/frontend && npm run dev
# Prints two URLs:
#   Local:   http://localhost:5173/
#   Network: http://192.168.1.42:5173/  ← phone uses this

Demo steps:

1. Click Trigger Surge — SURGE banner + QR code appear
2. Hand phone to a judge — scan the QR code
3. Phone opens /sos: tap SOS, allow microphone + location
4. Judge speaks to the voice agent; call appears in the Active Calls queue
5. Agent ends call automatically ~15 seconds after its closing line

Before the demo, configure the agent on the ElevenLabs dashboard:

Agent ID: agent_1701kr8n4kw9fr9aapm59ca3edg8

1. Closing line — replace the default with:

   "Emergency services have been dispatched to your location. While you wait: [one short situation-appropriate action]. Help is on the way."

2. Silence timeout — set to 15 seconds so the agent ends the session automatically

All events flow from backend → frontend over /ws. Every message type is handled in store/reducer.ts.

20 units pre-loaded at startup:

Heavy asset types (air_tanker, heavy_rescue, hazmat) require Protocol HOLD confirmation.

Eight zones across Yolo County with scores from 0 (low) to 1 (high vulnerability). A call is flagged vulnerable=true when zone score > 0.6 or the description mentions elderly/disabled/children/assisted living.

GeoJSON boundary for the 2024 Park Fire (Butte/Tehama counties) — rendered on the Leaflet map.

Requires the backend to be running and pip install websockets:

bash scripts/smoke_test.sh

Verifies: health check, state reset, call injection, WebSocket BRIEFING_READY delivery, all three /demo/* endpoints, and call queue population after surge injection.

1. Create signal/backend/data/transcripts/{id}.json:

{
  "id": "scenario_id",
  "title": "Display Name",
  "zone": "YL-01",
  "lat": 38.9,
  "lon": -122.1,
  "incident_type": "fire",
  "sentences": [
    "First sentence the caller says.",
    "Second sentence.",
    "..."
  ]
}

2. Add the entry to TRANSCRIPT_OPTIONS in signal/frontend/src/components/DemoControls.tsx.

Sentences stream at 1.5-second intervals. Claude Haiku runs field extraction every 2 sentences.

Set SURGE_THRESHOLD in signal/backend/.env (default: 10 calls/min). The MONITOR agent evaluates a sliding 60-second window every 5 seconds. After the rate drops below threshold, Surge Mode persists for 120 more seconds before reverting.

For local testing, /demo/trigger-surge bypasses the threshold by directly setting mode and lambda.

Built at HackDavis 2026 — UC Davis's annual social-good hackathon.

The scenario is grounded in the 2024 Park Fire (Butte/Tehama counties, California) — one of the largest recorded wildfires in California history, burning over 400,000 acres. The vulnerability zones, fire perimeter GeoJSON, and unit configurations reflect real Yolo County geography and CAL FIRE resource structures.

Key design constraints:

• The AI never communicates directly with callers
• Heavy asset dispatch requires explicit human confirmation every time
• All state is in-memory — no database, no external dependencies, demo-ready on first run
• The dispatcher can override any agent decision at any time