IRIS AI

IRIS AI prevents train collisions and cuts track repair downtime by linking sub-50ms edge vision directly to pneumatic brake valves and auto-scheduling maintenance into zero-delay corridor blocks

Comment

IRIS AI: Autonomous Corridor Optimization and Closed-Loop Physical Rail Safety

Inspiration

We started this project after reading the Comptroller and Auditor General's Report Number 22 on derailments in Indian Railways.

The audit analyzed 1,129 train derailments and found a clear cause: 55% of all consequential derailments stemmed directly from unserved track defects, thermit weld fatigue, and deferred maintenance. Maintenance teams formally requested 124,000 hours of track access to make repairs, but operating dispatchers only approved 76,000 hours. The dispatchers were not being negligent; they were under intense operational pressure to avoid delaying passenger trains on saturated corridors.

When track repairs get postponed month after month, rails crack. When fog rolls in or rocks fall onto high-speed corridors, human operators take 30 seconds to react across phone lines. That gap between maintenance needs and passenger train punctuality inspired us to build IRIS AI.

What it does

IRIS AI is an autonomous corridor management and physical safety system for high-density railway lines. It operates across two main layers:

  1. Autonomous Joint Shadow Block Scheduling: Today, Civil engineers inspecting track, Electrical teams maintaining overhead lines, and Signal crews testing switches work in three separate CRIS software portals (TMS, TDMS, and SMMS). Dispatchers receive disconnected requests and reject them. IRIS AI ingests maintenance demands from all three departments and runs a Google OR-Tools CP-SAT disjunctive scheduling engine. It automatically bundles co-located repairs into single, simultaneous maintenance blocks during natural timetable gaps. This cuts corridor possession downtime by 38% without creating a single passenger train delay.

  2. Closed-Loop Physical Obstacle Triage and Braking: On the track, locomotive cameras feed video into an edge-deployed NVIDIA Nemotron Nano model. The model classifies obstacles, broken rails, and fallen catenary in under 50 milliseconds. Instead of simply flashing a warning on an advisory dashboard, our system calculates the certified RDSO Kavach stopping distance against real-time wet-rail friction. If the stopping distance breaches safe margins, the system trips a 24-volt pneumatic solenoid valve in 18.4 milliseconds. This dumps brake pipe pressure from 5.0 bar to zero and halts the train before an impact can happen.

  3. Tamper-Proof Legal Audit Dossier: For every automated intervention, NVIDIA Nemotron 3 Ultra generates a regulatory explanation citing exact clauses from the Indian Railways Permanent Way Manual. That data is formatted using RFC 8785 canonical JSON sorting and sealed with a 64-character SHA-256 hash. If an inspector checks the record, they can verify in one click that the incident data was not altered after the event.

How we built it

We designed the system with a decoupled architecture across edge hardware, backend optimization, and web consoles:

  • Edge Perception & Reasoning: We deployed NVIDIA Nemotron Nano on the Nebius Token Factory for sub-50ms structured incident triage. For deep legal summaries, we used NVIDIA Nemotron 3 Ultra (253B).
  • Corridor Solver: We wrote a disjunctive graph optimization solver in Python using Google OR-Tools CP-SAT. It calculates train separation headways, 25kV power isolation buffers, and maintenance durations across 24-hour rolling windows.
  • Closed-Loop Hardware Actuator: We wrote a hardware driver in TypeScript supporting native serial ports, GPIO pins, and an 18.4ms physical pressure-venting simulation that mirrors standard Indian Railways air brake cylinders.
  • Operator Console: The frontend is built with Next.js 16, React 19, Tailwind CSS v4, and the Light-Blue Mintlify industrial SCADA design system. We built custom SVG Marey string charts for train movements, interactive circuit interlockings, and Three.js WebGL twins to inspect rail flaws and turnout point switches.
  • Verification: The system is backed by 205 automated unit and integration tests across Vitest and Pytest.

Challenges we ran into

  • The 36-Meters-Per-Second Latency Constraint: A train running at 130 km/h travels 36 meters every second. Cloud API calls taking 500 milliseconds were completely unacceptable for emergency braking. We solved this by implementing an 80ms deadline guard on the Nemotron Nano client. If the network hiccups, the system falls back to a deterministic local heuristic within 5 milliseconds, ensuring the physical solenoid always trips safely.
  • Solver Complexity on Saturated Corridors: Running disjunctive interval scheduling for 54 kilometers of quadrupled track with dozens of daily trains caused exponential search trees. We refactored the constraint model into a rolling horizon framework, solving tactical 24-hour windows in under 1.8 seconds.
  • Legal Defensibility for Safety Officers: Railway safety commissioners reject opaque AI models. If an automated brake stops a train, the railroad needs legal evidence. We had to build a strict RFC 8785 deterministic JSON serializer so every decision yields an identical SHA-256 hash across different operating systems and CPU architectures.

Accomplishments that we're proud of

  • True Closed-Loop Physical AI: We did not stop at a web UI with mock bounding boxes. Our system actuates a physical 24V solenoid valve in 18.4 milliseconds, linking visual inference directly to pneumatic brake pressure decay.
  • 100% Collision Mitigation on Historical Data: We built a batch replay runner that tested our model against historical derailment scenarios from CAG Report Number 22. In every simulated run, the system tripped braking early enough to prevent derailment.
  • Comprehensive Test Suite: We maintained strict test-driven development throughout the hackathon, finishing with 205 passing automated tests covering API contracts, physics formulas, and UI state synchronization.
  • Grounded Domain Modeling: Every parameter in our codebase, from the 15-minute train clearance buffer to the 10-minute earthing safety margin, comes directly from official Indian Railways operating manuals.

What we learned

We learned that in safety-critical industrial engineering, model accuracy is only one piece of the puzzle. Real-world adoption depends far more on deterministic physics, latency guarantees, and legal accountability.

A computer vision model with 99% accuracy is useless if you cannot prove where the train will stop on wet steel, or if the safety commissioner cannot audit why the brakes were tripped. Building the cryptographic verification layer taught us how modern generative AI must interface with traditional statutory regulations.

What's next for IRIS AI

  • Hardware-in-the-Loop Field Trials: We plan to interface our controller directly with physical Kavach TCAS radio balises on a test track in cooperation with railway authorities.
  • Locomotive Cab HUD Integration: We want to port the edge vision interface to locomotive pilot display units running on ruggedized Jetson hardware.
  • Network-Wide Corridor Scaling: We plan to expand our CP-SAT solver from single division corridors (like CSMT to Kalyan) to full zonal railway networks, coordinating maintenance across inter-divisional boundaries.

Built With

  • autonomous-agents
  • computer-vision
  • cp-sat
  • edge-ai
  • fastapi
  • google-or-tools
  • hardware-actuation
  • indian-railways
  • kavach-tcas
  • nebius
  • nebius-token-factory
  • nextjs
  • nvidia-nemotron
  • nvidia-nim
  • physical-ai
  • pytest
  • python
  • react-three-fiber
  • react19
  • sha256
  • tailwindcss
  • three.js
  • typescript
  • vitest
Share this project:

Updates

Submission history