Skip to content
Blue M letter mark on a light background, standing in for my photo until I add one.Manoj

Rakshak AI

An AI-driven crisis-response platform that analyzes incidents, identifies nearby emergency resources, and prepares dispatch actions under human approval.

2026 · Solo · Prototype

ReactNode.jsExpressFastAPIPythonLangGraphGeminiWebSocketsTwilio
Live prototype (opens in new tab)Source (opens in new tab)

The problem

Emergency response workflows often involve fragmented information, manual coordination, and delays between detecting an incident and contacting the right people. Rakshak AI explores whether an AI agent can structure that workflow in real time — from incident analysis and threat scoring to nearby responder selection and dispatch preparation — while keeping a human in control of high-stakes actions.

How it works

  1. Incident detected

    Sensor or dashboard input enters the system.

  2. Agent analyzes

    LangGraph classifies the incident and evaluates severity.

  3. Nearby resources ranked

    Geospatial tools find and score relevant emergency resources.

  4. Human approval

    High-stakes dispatch pauses for explicit operator approval.

  5. Alert dispatched

    Approved actions trigger the notification workflow.

A LangGraph workflow processes the incident through structured stages while the dashboard receives live execution updates.

What I built

  • Solo: I designed and built a three-tier application combining a React command dashboard, a Node.js orchestration layer, and a Python LangGraph agent.
  • Built the React command center with live agent status, threat visualization, responder maps, decision states, and operator controls.
  • Implemented a Python FastAPI/LangGraph workflow for incident detection, threat scoring, intelligence gathering, responder ranking, dispatch decisions, and resolution.
  • Built a Node.js relay layer connecting the frontend, Python agent, WebSocket sessions, and external notification services.
  • Integrated geospatial APIs to discover and evaluate nearby emergency resources.
  • Added a human-in-the-loop checkpoint before high-stakes dispatch actions.
  • Added audit logs, health endpoints, safety validation, and API fallbacks for degraded-service scenarios.

Decisions

Human approval before dispatch

High-stakes external actions are gated behind an explicit operator confirmation step, including a short approval window, so the agent cannot independently trigger emergency dispatch.

LangGraph for the agent workflow

LangGraph was used to model the crisis workflow as explicit stages for detection, intelligence gathering, service scoring, decision-making, alerting, and confirmation.

WebSockets for live execution

Crisis processing is not a single request/response operation. The agent produces intermediate events such as threat assessments, intelligence, service scores, and decisions, so WebSocket communication streams those updates back to the dashboard in real time.

Architecture

React Command Center
  → Node / Express Relay
  → FastAPI
  → LangGraph Agent
  → Gemini + External Tools
Side integrations:
Overpass / OpenStreetMap
TomTom / OSRM
Twilio

The frontend provides the operator dashboard, Node.js manages the application relay and WebSocket sessions, and the Python service runs the LangGraph agent.

Results and evaluation

Deployment
Frontend deployed; backend services configured on Render.
Submitted
Google Solution Challenge 2026 (Build with AI, via Hack2Skill) — certificate. (opens in new tab)
Agent workflow
End-to-end crisis pipeline implemented with LangGraph.
Human safety
High-stakes dispatch gated behind explicit operator approval.
External integrations
Geospatial lookup, routing/traffic, and SMS integrations.
Evaluation
Tested through built-in crisis scenarios and simulated dispatch flows.
Note
This is a prototype, not a production emergency service. Its purpose is to demonstrate the architecture, agent workflow, and human-oversight model rather than claim real-world emergency-response reliability.

What I'd change

Next steps

  • Replace simulated scenarios with a labeled evaluation set covering different incident types and edge cases.
  • Measure classification quality, responder-ranking quality, end-to-end latency, and false-dispatch rate.
  • Persist structured incident and agent traces for reproducible evaluation instead of relying mainly on in-memory history.
  • Add stronger authentication, authorization, rate limiting, and secrets management before any real-world deployment.
  • Separate simulated actions from production emergency-service integrations.