Unilert

Real-time incident command, distilled into decisive action.

Comment

Inspiration

Emergency response today is fragmented. EMS supervisors and incident commanders are forced to synthesize critical decisions from radio chatter, CAD systems, hospital calls, maps, and spreadsheets—all under extreme time pressure. The Incident Command System (ICS) provides a strong framework, but the execution still depends on human bandwidth.

We were inspired by a simple question:
What if the operational picture and next actions were computed instantly, instead of manually assembled?

Unilert was built to compress chaos into clarity—giving responders a real-time decision surface instead of a delayed report.

What it does

Unilert is a real-time coordination layer for medical incidents.

A user inputs the minimal situation:

  • what happened
  • where it is
  • estimated patients
  • hazards and constraints

Unilert immediately returns:

  • where patients should go
  • the primary bottleneck
  • the next 3 actions
  • who owns each action
  • a continuously updating operational picture

It follows ICS principles:

  • structured command hierarchy
  • actionable Incident Action Plans (IAPs)
  • clear ownership and span of control
  • real-time updates as conditions change

The system behaves less like a report generator and more like a live operations assistant.

How we built it

We built Unilert as a hybrid decision system combining deterministic logic with distributed AI agents.

Core architecture

  • FastAPI backend for orchestration and API
  • Next.js frontend for a real-time decision interface
  • SQLite (WAL mode) for lightweight state persistence
  • OSRM for routing and travel estimation

Decision pipeline

We implemented a two-speed system:

  1. Immediate Decision Engine (local)

    • Normalizes incident input
    • Computes triage distribution and hospital allocation
    • Identifies bottlenecks
    • Generates the first operational plan in ~2–5 seconds

  2. Dedalus Machines Swarm (distributed)

    • Each agent runs on its own machine:
      • Situation Unit (parsing & normalization)
      • Risk Assessor (hazards & escalation)
      • Operations Planner (action refinement)
      • Communications Officer (message generation)
    • These agents run in parallel and enhance the plan without blocking it

This separation ensures speed without sacrificing depth.

Challenges we ran into

1. Latency vs usefulness

Initial versions produced detailed outputs—but too slowly. In real incidents, a 60–120 second delay is unacceptable.
We had to redesign the system so the first answer is immediate, and everything else is incremental.

2. Dedalus execution reliability

While Dedalus Machines enabled powerful agent swarming, we faced:

  • queued execution delays
  • SSH readiness failures
  • intermittent runtime errors

We solved this by:

  • making swarm execution non-blocking
  • adding fallback logic
  • ensuring the system still works without remote agents

3. Credit and dependency constraints

We discovered that relying on external inference (LLMs/APIs) creates fragility:

  • rate limits
  • cost constraints
  • failure points

So we shifted critical logic into deterministic code, using agents only for enrichment.

4. Overengineering early outputs

Early outputs tried to do too much:

  • long narratives
  • excessive analysis
  • non-actionable detail

We refocused on: $$ \text{Decision Value} = \frac{\text{Actionable Insight}}{\text{Time}} $$

Maximizing this ratio became a guiding principle.

Accomplishments that we're proud of

  • Built a real-time decision surface instead of a static AI report
  • Successfully integrated Dedalus Machines for agent swarming
  • Designed a fail-safe system that still operates under degraded conditions
  • Translated ICS doctrine into executable logic
  • Reduced decision latency from minutes → seconds

Most importantly, we built something that aligns with how responders actually think and act.

What we learned

  • Speed matters more than completeness in high-stakes environments
  • AI is most powerful when paired with deterministic structure
  • Systems should degrade gracefully, not catastrophically
  • Real users don’t want “analysis”—they want decisions
  • Architecture matters as much as intelligence

We also learned that aligning with real-world frameworks like ICS is critical—technology must fit the system, not replace it.

What's next for Unilert

  • True distributed scaling (move beyond SQLite to a shared DB)
  • Live data integrations (hospital capacity, EMS feeds, CAD systems)
  • Improved routing intelligence with dynamic constraints
  • Better swarm reliability on Dedalus Machines
  • Simulation and training mode for EMS agencies
  • Multi-agency unified command support

Long term, we want Unilert to become the standard decision layer for incident response—augmenting human command, not replacing it.

Built With

Share this project:

Updates