Building AI-Powered Airline Revenue Management Systems with KaibanJS: A Developer’s Guide

// The inconsistent reality 😅
const analystDecisions = {
  juniorAnalyst: "Let's decrease fares by 15% to fill seats",
  seniorAnalyst: 'Hold steady, demand looks stable',
  veteranAnalyst: "Increase by 8% - I've seen this pattern before"
};

import { Agent, Task, Team } from 'kaibanjs';

// 🧠 The Brain - Best Practice Recommendations Agent
const bestPracticeRecommendationsAgent = new Agent({
  name: 'Best Practice Recommendations Agent',
  role: 'Pricing Strategy Specialist',
  goal: 'Suggest optimal pricing actions based on airline policy, market data and proven strategies, following the specific instructions for fare analysis.',
  background:
    'Expert pricing strategist with deep knowledge of airline revenue management best practices, competitive analysis, and fare optimization. Specializes in applying standardized decision-making frameworks to ensure consistent recommendations.',
  tools: [new PricingSystemIntegrationTool()]
});

// 🔍 The Quality Guardian - Automated Quality Checks Agent
const automatedQualityChecksAgent = new Agent({
  name: 'Automated Quality Checks Agent',
  role: 'Compliance and Risk Specialist',
  goal: 'Review proposed pricing actions for compliance and consistency, flagging deviations or risks before implementation.',
  background:
    'Compliance and risk management expert with expertise in airline pricing policies, regulatory requirements, and quality assurance processes. Specializes in automated validation and risk assessment.',
  tools: [new NotificationTool()]
});

const generateRecommendationsTask = new Task({
  title: 'Best Practice Recommendations',
  description: `Generate fare recommendations following the EXACT instructions from the analysis guidelines:

    INSTRUCTION 1: Demand Trend Analysis (PRIORITY RULE)
    - If Demand Trend = INCREASING: Limit fare changes to maximum 5% (conservative approach for growing demand)
    - If Demand Trend = DECREASING: Set fare equal to Competitor Median Price (competitive positioning)
    - If Demand Trend = STABLE: Apply standard rules below

    INSTRUCTION 2: Competitor Analysis
    - Compare Model Fare against competitor median pricing
    - If significantly below market (>$50 gap): Recommend fare increase to 95% of competitor median
    - If significantly above market (>$100 gap): Recommend fare decrease to 102% of competitor median

    INSTRUCTION 3: Load Factor Optimization
    - If Load Factor > 0.8 (HIGH): Recommend 5% fare increase
    - If Load Factor < 0.6 (LOW): Recommend 5% fare decrease

    INSTRUCTION 4: Special Events Consideration
    - If special event includes "festival" or "tournament": Recommend 8% fare increase
    - If special event includes "competitor": Recommend 8% fare decrease

    INSTRUCTION 5: Weekday Pricing Adjustment
    - If WeekDay = 5, 6, or 7 (Weekend): Premium pricing justified, can be above competitor median
    - If WeekDay = 1-4 (Weekday): Competitive pricing required, should align with or be below competitor median

    INSTRUCTION 6: Calculate and Flag Changes
    - Calculate percentage change: ((AI Suggested Fare - Model Fare) / Model Fare) * 100
    - If change > 10%: Flag as SIGNIFICANT_CHANGE requiring management approval
    - If change ≤ 10%: Mark as standard recommendation

    Apply these rules in order of priority, with Demand Trend taking precedence over other factors.`,
  expectedOutput: `Structured fare recommendation output in the following EXACT format:

    ## FARE RECOMMENDATION SUMMARY

    **Route:** [Origin-Destination]
    **Analysis Date:** [Date]
    **Current Model Fare:** $[Amount]

    ### RECOMMENDATION DETAILS

    **AI Suggested Fare:** $[Calculated Amount]
    **% change vs Model:** [Percentage]% [↑/↓]
    **AI Justification:** [Detailed justification following instruction format]

    ### SIGNIFICANCE FLAGS

    **Change Magnitude:** [STANDARD/SIGNIFICANT_CHANGE]
    **Approval Required:** [YES/NO]
    **Priority Level:** [HIGH/MEDIUM/LOW]
    **Risk Assessment:** [LOW/MEDIUM/HIGH]

    ### SUPPORTING DATA

    **Competitor Median:** $[Amount]
    **Load Factor:** [Value] ([HIGH/MEDIUM/LOW])
    **Demand Trend:** [INCREASING/DECREASING/STABLE]
    **WeekDay:** [Day Number] ([Weekend/Weekday])
    **Special Events:** [Event details or "None"]
    **Market Position:** [BELOW_MARKET/AT_MARKET/ABOVE_MARKET]

    Ensure all calculations are accurate and justifications follow the exact instruction format.`,
  agent: bestPracticeRecommendationsAgent
});

const team = new Team({
  name: 'Standardized Revenue Management Analysis Team',
  agents: [
    guidedDataAnalysisAgent,
    bestPracticeRecommendationsAgent,
    automatedQualityChecksAgent,
    continuousLearningAgent
  ],
  tasks: [
    collectRouteDataTask,
    performGuidedAnalysisTask,
    generateRecommendationsTask,
    performQualityChecksTask,
    captureKnowledgeTask,
    generateSummaryTask
  ],
  inputs: {
    origin: 'LHR',
    destination: 'SLC',
    analysisDate: '2026-06-03'
  },
  env: {
    OPENAI_API_KEY:
      import.meta.env.VITE_OPENAI_API_KEY || 'YOUR_OPENAI_API_KEY_HERE'
  }
});

export default team;

// Before: Inconsistent decisions
const before = {
  analyst1: 'Increase fare by 5%',
  analyst2: 'Decrease fare by 10%',
  analyst3: 'Keep current fare'
};

// After: Standardized AI-driven decisions
const after = {
  aiAgent:
    'Increase fare by 3.2% based on competitor median ($642) and high load factor (0.71)'
};

const learningCycle = {
  capture: 'Store analysis results and outcomes',
  analyze: 'Identify successful patterns and failures',
  update: 'Refine best practices and rules',
  share: 'Distribute learnings across the team'
};

npm install kaibanjs

// .env file
VITE_OPENAI_API_KEY = your_openai_api_key_here;

import team from './revenue-management-analysis.team.kban.js';

// Execute the team workflow
const results = await team.execute({
  origin: 'LHR',
  destination: 'SLC',
  analysisDate: '2026-06-03'
});

console.log('Revenue Management Analysis Complete:', results);

const marketIntelligenceAgent = new Agent({
  name: 'Market Intelligence Agent',
  role: 'Market Research Specialist',
  goal: 'Analyze market trends and competitor behavior patterns'
  // ... configuration
});

const customPricingRules = {
  seasonalAdjustment: 'Apply 12% premium during holiday seasons',
  routeSpecificRules: 'Premium routes get 5% higher margins',
  customerSegmentRules: 'Business travelers accept 15% premium'
};

const weatherImpactTool = new Tool({
  name: 'weather_impact_analysis',
  description: 'Analyze weather impact on demand and pricing',
  schema: z.object({
    route: z.string(),
    weatherCondition: z.string(),
    impactLevel: z.enum(['LOW', 'MEDIUM', 'HIGH'])
  })
});

import { z } from 'zod';

const pricingSchema = z.object({
  currentFare: z.number().positive(),
  recommendedFare: z.number().positive(),
  justification: z.string().min(10)
});

// Changes to agent configurations are reflected immediately
const agent = new Agent({
  // Update this and see changes instantly
  goal: 'Updated goal based on new business requirements'
});

// Built-in logging for debugging and monitoring
console.log('Agent execution trace:', agent.getExecutionTrace());
console.log('Task performance metrics:', task.getMetrics());

// ❌ Too complex
const complexRule =
  'If demand > 0.8 AND competitor < model AND weekday = weekend AND weather = good AND season = peak THEN increase by 12.5%';

// ✅ Clear and maintainable
const simpleRule = 'If demand trend = INCREASING: Limit changes to 5%';

// Always handle edge cases
const safeCalculation = (currentFare, recommendedFare) => {
  if (currentFare <= 0) throw new Error('Invalid current fare');
  if (recommendedFare <= 0) throw new Error('Invalid recommended fare');

  return ((recommendedFare - currentFare) / currentFare) * 100;
};