Build a Real-World IROPS Re-accommodation Workflow with KaibanJS – ██FR█████ █INTELL███████████

This content originally appeared on DEV Community and was authored by Dariel Vila

What Are IROPS and Why Automate Them?

IROPS, short for “irregular operations,” are disruptions like flight delays, cancellations, diversions, or missed connections. These events can cascade through an airline’s network, leading to massive costs and frustrated passengers.

By automating re-accommodation workflows, airlines can reduce operational strain, improve passenger experience, and respond in real time while saving millions.

What We’re Building

Here’s the workflow model we’ll implement using KaibanJS:

Detect Disruption — Identify delays or missed connections, especially in tight turn scenarios.
Generate Options — Create ranked re-accommodation options based on fare class, loyalty status, seat preference, and availability.
Orchestrate Workflow — Use KaibanJS to wire agents and tasks into a single cohesive flow.
Scale With Ease — Seamlessly add communication, booking updates, and staff coordination without refactoring the core.

This structure enables a functional, extendable, and production-ready response to real-world IROP scenarios, all within JavaScript.

Step-by-Step Implementation in KaibanJS

1. Define Domain-Specific Agents

    const realtimeDisruptionDetectionAgent = new Agent({
      name: 'Realtime Disruption Detection Agent',
      role: 'Flight Monitoring Specialist',
      goal: 'Detect operational disruptions impacting connections.',
      tools: [ new FlightMonitorTool() ]
    });

    const intelligentOptionGenerationAgent = new Agent({
      name: 'Intelligent Option Generation Agent',
      role: 'Network Optimization Specialist',
      goal: 'Identify viable re-accommodation options considering constraints.',
      tools: [ new InventorySearchTool() ]
    });

Agents encode purpose: both what they do and why making workflows understandable and maintainable.

2. Define Tasks Grounded in Domain Needs

const detectDisruptionTask = new Task({
  title: 'Realtime Disruption Detection',
  description: `Monitor flight status for flight {flightNumber} from {origin} to {destination} scheduled for {scheduledDeparture}. 
    Detect any disruptions and assess impact on passengers. The agent should identify IROPS before passengers become aware of issues.
    Focus on connection scenarios where passengers miss their connecting flights due to delays.`,
  expectedOutput:
    'Detailed disruption report with affected passenger list, connection details, and estimated delay duration.',
  agent: realtimeDisruptionDetectionAgent
});

const generateOptimalOptionsTask = new Task({
  title: 'Intelligent Option Generation',
  description: `Based on the connection disruption detected, search for optimal re-accommodation options for {affectedPassengers} passengers. 
    Consider factors such as:
    - Available seats across the network from connection airport to final destination
    - Passenger loyalty status and fare class
    - Connection preferences and timing
    - Operational constraints and aircraft availability
    - Individual passenger preferences and special assistance needs
    - Alternative routes and airports if direct flights are not available`,
  expectedOutput:
    'Ranked list of optimal re-accommodation alternatives with detailed flight information and seat availability.',
  agent: intelligentOptionGenerationAgent
});

const reaccommodatePassengersTask = new Task({
  title: 'Re-accommodate Passengers',
  description: `Using the available flights and passenger preferences, apply re-accommodation logic for missed connections:
    - Sort passengers by loyalty status (PLATINUM > GOLD > SILVER)
    - Match fare class availability (F for First Class, Y for Economy)
    - Assign seats based on preferences (WINDOW/AISLE)
    - Handle special assistance requirements
    - Distribute passengers optimally across available flights
    - Ensure network utilization is maximized
    - Consider alternative airports if necessary (e.g., FLL instead of MIA)`,
  expectedOutput:
    'Complete re-accommodation results for each passenger with new flight and seat assignments, including connection details.',
  agent: intelligentOptionGenerationAgent
});

Tasks clarify expectations, keeping code verifiable and business focused.

3. Use a Team to Wire Agents, Tasks, and Inputs

    const team = new Team({
      name: 'IROPS Re-accommodation Team',
      agents: [ realtimeDisruptionDetectionAgent, intelligentOptionGenerationAgent ],
      tasks: [ detectDisruptionTask, generateOptionsTask, reaccommodatePassengersTask ],
      inputs: {
        flightNumber: 'AA930',
        origin: 'GRU',
        destination: 'MIA',
        scheduledDeparture: '2024-01-15T08:00:00Z',
        affectedPassengers: mockPassengers.length
      },
      env: { OPENAI_API_KEY: 'YOUR_OPENAI_API_KEY' }
    });

    team.start().then(result => {
      console.log('Workflow completed:', result);
    });

This arrangement ensures both clarity and flexibility, additional agents for booking updates, notifications, and staff alerts can be added without disrupting the original flow.

Try It Live & Explore Further

See real-world examples, including the airline case, and learn how others are leveraging KaibanJS in production: https://www.kaibanjs.com/examples/multi-agent-airline-reaccommodation
Learn about the core abstractions Agents, Tasks, Teams via KaibanJS documentation: https://docs.kaibanjs.com/get-started/Core-Concepts-Overview
View & run the full example in: KaibanJS Playground

Summary

Key Aspect	Benefit
JS-native implementation	No context-switching—streamline your tech stack
Role-based agents	Better traceability, maintainability, and clarity
Task separation	Easier to test and extend business logic
Visual orchestration	Debug and explain agent workflows with ease

This content originally appeared on DEV Community and was authored by Dariel Vila