VitalPath AI

VitalPath AI — Navigate smarter. Save time. Save lives.

Comment

VitalPath AI

Mission: Faster, safer organ transport. Smarter decisions under pressure. More lives saved.

Safety & Compliance Disclaimer: VitalPath AI is a hackathon prototype for demonstration and research exploration. It is not a medical device, not certified clinical decision support, and must not be used to make real patient-care decisions or real transport/dispatch decisions. AI outputs are advisory only and must be validated against official protocols. Do not enter real patient identifiers (no PHI).

About the Project (What VitalPath AI Is)

VitalPath AI is an AI-assisted logistics dashboard for life-critical medical shipments, starting with organ donation transport (and extendable to blood, vaccines, and other cold-chain cargo).

The core idea is simple:
When an organ is moving from donor hospital → recipient hospital, teams should not be juggling disconnected tools (maps, phone calls, paperwork, sensor readouts, and “what do we do now?” decisions). VitalPath pulls that into one mission screen:

  • Auto-destination: donor + recipient hospitals are identified automatically (no manual address entry).
  • Organ-aware routing: route + transport mode are chosen based on organ type and time constraints.
  • Real road-law navigation: directed road network routing (one-ways respected) with turn-by-turn telemetry.
  • Vehicle simulation: GPS-style movement along the route for a demo that feels real.
  • Cargo monitoring: temperature, shock/impact, lid seal, battery, elapsed time (simulated or live).
  • AI safety guardian: concise, actionable recommendations (risk level + what to do next).
  • Mission log: every alert, reroute, and decision is recorded for traceability.

What Inspired Us

We started from a response-time problem: in emergencies, seconds matter—but systems are often fragmented.
Then we asked: What’s another healthcare domain where time, routing accuracy, and high-stakes decisions collide?

Organ donation stood out immediately.

A donated organ isn’t just “cargo.” It’s a countdown with a patient waiting at the other end. Even small disruptions—wrong turns, reroute delays, temperature drift, a lid seal issue—can compound into lost viability.

We wanted VitalPath to feel like a safety guardian: something that quietly watches all the moving parts (route, ETA, constraints, sensors) and helps teams act early instead of reacting late.

What We Built (And What’s “Real” in the Demo)

✅ Real Today (in our prototype)

  • Road-law routing on OpenStreetMap “drive” networks (directed graph: one-ways respected).
  • Turn-by-turn navigation telemetry, including:
    • next maneuver + distance-to-next-turn
    • current street
    • remaining distance + ETA
  • GPS-style simulation (vehicle marker follows the route polyline and stays on-road/snapped).
  • Auto-destination workflow (mission loads donor → recipient automatically).
  • Organ-aware transport decisioning (road vs air vs hybrid suggested based on urgency + distance + constraints).
  • Cargo telemetry dashboard (temperature, shock, lid, battery, elapsed time; simulated feed).
  • AI assistant for:
    • “Is viability at risk?”
    • “Should we change mode?”
    • “What’s the next best action?”
  • Mission log to record key events (alerts, reroutes, mode switches, timeline points).
  • Algorithmic telemetry comparing shortest path methods:
    • Dijkstra baseline
    • Duan–Mao BM-SSSP experimental accelerator path (benchmark + race visualization)

🔜 What’s Next (roadmap)

  • WebSocket incident feeds (closures, disruptions) → automated reroute logic
  • Offline-cached regional graphs for reliability
  • Immutable “black box” logs for compliance + training replay
  • Multi-unit optimization (best courier/vehicle/air option by travel time)
  • Structured handoff + chain-of-custody generation

How We Built It

Architecture

Frontend

  • React + TypeScript (Vite)
  • MapLibre GL (OSM-friendly map rendering)
  • TailwindCSS for dashboard layout
  • Recharts for telemetry charts and “algorithm race” visuals

Backend

  • FastAPI (Python) with /docs interactive API
  • OSMnx + NetworkX for:
    • graph retrieval
    • directed road routing
    • path coordinate generation
  • Optional Node/TS runner for BM-SSSP experimentation
  • AI endpoints:
    • Gemini (assistant reasoning + summaries)
    • optional ElevenLabs (TTS), with demo fallbacks

Routing + Telemetry (What the backend returns)

We treat a route like a timeline with data aligned to points:

  • path_coordinates[] (polyline)
  • cum_distance_m[] and cum_time_s[] aligned to polyline points
  • steps[] (maneuvers derived from bearings + street changes)
  • totals:
    • total_distance_m
    • total_time_s

The frontend uses this to compute “live” navigation:

  • distance to next maneuver
  • remaining ETA
  • current street
  • progress along route

Organ-Aware Auto-Decisioning (Concept + Demo Logic)

VitalPath selects a transport plan based on:

  • organ type (heart, lung, liver, kidney, pancreas)
  • maximum safe transport time
  • route ETA and distance

We model the core decision rule as:

[ \text{If } \text{ETA}{road} \le T{\max}(\text{organ}) \Rightarrow \text{road} ] [ \text{Else } \Rightarrow \text{air or hybrid (road → air → road)} ]

Important realism note: In real operations, this would incorporate aviation availability, weather, policy, coordination constraints, and verified clinical guidance. Our demo focuses on the routing/telemetry logic and the decision workflow.

Challenges We Faced (And How We Solved Them)

1) Making the demo “feel real”

A static route isn’t enough—judges need to experience the mission.
We built a simulation loop that keeps the vehicle snapped to road geometry and updates navigation telemetry continuously.

2) Directed road-law routing + snapping issues

Real maps include one-ways, private roads, and points “inside buildings.”
We handled this by snapping start/end to nearest drivable nodes and routing on the directed drive network.

3) Rerouting under disruption

In organ transport, reroute latency matters.
We designed for recomputation: routing is not “compute once.” If a closure appears or mode changes, the system recomputes and the UI updates quickly.

4) Responsible AI boundaries

It’s easy to make AI sound authoritative in healthcare. We avoided that.

  • AI outputs are labeled advisory
  • we structured prompts for concise, operational recommendations
  • we included explicit disclaimers and “no PHI” warnings

5) Benchmarking new algorithms honestly

We didn’t want a “magic algorithm” claim.
So we built visible telemetry showing:

  • speed comparisons
  • explored footprint
  • run distributions (repeat runs)
  • and we kept Dijkstra as the default, with fallback if BM-SSSP isn’t beneficial.

What We Learned

  • Healthcare workflows are systems problems. The biggest wins often come from reducing cognitive load, not adding features.
  • Routing isn’t just navigation—it’s operations. The moment you add incidents, constraints, and repeated queries, recomputation becomes critical.
  • Trust is a feature. Especially with AI in healthcare: safety disclaimers, audit trails, and cautious output design are not optional.
  • Evidence matters. If you claim performance improvements, show benchmarks and the conditions where it helps—and where it doesn’t.

Why VitalPath AI Matters

VitalPath isn’t trying to replace human judgment.
It’s trying to protect it—by making the mission status, constraints, risks, and next actions easy to understand in seconds.

Because in organ donation transport, every minute is not just time.

It’s viability.
It’s a waiting patient.
It’s a life.

Built With

Share this project:

Updates