AI Agent for Travel & Hospitality: Automate Booking, Revenue & Guest Experience

Hotels leave an average of 15-20% of potential revenue on the table through suboptimal pricing, manual booking management, and one-size-fits-all guest experiences. Airlines fare even worse — empty seats on a departing flight are lost revenue forever. AI agents are transforming travel and hospitality by making real-time decisions across pricing, operations, and personalization that no human revenue manager could match at scale.

This guide covers 6 production-ready AI agent workflows for travel and hospitality, with architecture decisions, code examples, and ROI numbers from real deployments.

1. Revenue Management Agent

Revenue management is the highest-impact application of AI in hospitality. The agent sets optimal room rates across all channels, adjusting prices multiple times per day based on demand signals, competitor rates, events, weather, and booking pace.

Dynamic Pricing Architecture

import numpy as np
from datetime import datetime, timedelta

class RevenueManagementAgent:
    """AI agent for hotel revenue optimization."""

    def __init__(self, demand_model, competitor_monitor, booking_engine):
        self.demand = demand_model
        self.competitors = competitor_monitor
        self.bookings = booking_engine
        self.min_rate_multiplier = 0.6  # Never go below 60% of rack rate
        self.max_rate_multiplier = 2.5  # Cap at 250% of rack rate

    def optimize_rates(self, hotel_id: str, date: str) -> dict:
        """Calculate optimal rates for all room types on a given date."""
        days_out = (datetime.strptime(date, '%Y-%m-%d') - datetime.now()).days
        current_occupancy = self._get_occupancy(hotel_id, date)
        booking_pace = self._get_booking_pace(hotel_id, date)

        # Demand signals
        local_events = self._get_events(hotel_id, date)
        weather = self._get_weather_forecast(date)
        comp_rates = self.competitors.get_rates(hotel_id, date)
        historical = self._get_historical(hotel_id, date)

        # Demand score (0-100)
        demand_score = self.demand.predict(
            occupancy=current_occupancy,
            booking_pace=booking_pace,
            days_out=days_out,
            day_of_week=datetime.strptime(date, '%Y-%m-%d').weekday(),
            events=local_events,
            weather=weather,
            comp_avg_rate=comp_rates.get('avg'),
            historical_occupancy=historical['avg_occupancy']
        )

        rates = {}
        for room_type in self._get_room_types(hotel_id):
            rack_rate = room_type['rack_rate']
            rooms_available = room_type['available']
            rooms_total = room_type['total']
            fill_rate = 1 - (rooms_available / rooms_total)

            # Base multiplier from demand
            if demand_score > 80:
                multiplier = 1.5 + (demand_score - 80) * 0.05
            elif demand_score > 60:
                multiplier = 1.0 + (demand_score - 60) * 0.025
            elif demand_score > 40:
                multiplier = 0.85 + (demand_score - 40) * 0.0075
            else:
                multiplier = 0.6 + demand_score * 0.00625

            # Scarcity premium (fewer rooms = higher price)
            if fill_rate > 0.9:
                multiplier *= 1.2 + (fill_rate - 0.9) * 3  # Aggressive near sellout
            elif fill_rate > 0.75:
                multiplier *= 1.05

            # Last-minute adjustments
            if days_out <= 1 and fill_rate < 0.5:
                multiplier *= 0.75  # Fire sale for tonight
            elif days_out <= 1 and fill_rate > 0.8:
                multiplier *= 1.3  # High demand, sell remaining at premium

            # Competitor positioning
            if comp_rates.get('avg'):
                position = (rack_rate * multiplier) / comp_rates['avg']
                if position > 1.3:  # Too expensive vs competition
                    multiplier *= 0.95
                elif position < 0.7:  # Underpriced
                    multiplier *= 1.1

            # Apply constraints
            multiplier = max(self.min_rate_multiplier,
                           min(self.max_rate_multiplier, multiplier))

            optimal_rate = round(rack_rate * multiplier, 0)

            rates[room_type['code']] = {
                'rate': optimal_rate,
                'multiplier': round(multiplier, 2),
                'demand_score': demand_score,
                'competitor_avg': comp_rates.get('avg'),
                'fill_rate': f"{fill_rate*100:.0f}%",
                'confidence': self._calc_confidence(days_out, booking_pace)
            }

        return rates

    def optimize_length_of_stay(self, hotel_id: str, date: str) -> dict:
        """Set minimum stay and length-based pricing."""
        occupancy_map = {}
        for d in range(7):
            check_date = (datetime.strptime(date, '%Y-%m-%d') + timedelta(days=d)).strftime('%Y-%m-%d')
            occupancy_map[d] = self._get_occupancy(hotel_id, check_date)

        # If shoulder nights are low-occupancy, incentivize longer stays
        peak_occ = max(occupancy_map.values())
        shoulder_occ = min(occupancy_map.values())

        if peak_occ > 0.85 and shoulder_occ < 0.5:
            # High demand core + low demand shoulders
            return {
                'min_stay': 2,
                'discount_3_night': 10,
                'discount_5_night': 18,
                'discount_7_night': 25,
                'strategy': 'length_incentive'
            }
        elif peak_occ > 0.9:
            return {
                'min_stay': 3 if peak_occ > 0.95 else 2,
                'discount_3_night': 0,
                'strategy': 'minimum_stay_restriction'
            }
        else:
            return {
                'min_stay': 1,
                'discount_3_night': 5,
                'strategy': 'open_pricing'
            }

Channel Distribution

The agent also manages rate parity and distribution across channels:

• Direct bookings — Best rate guarantee, push loyalty members here (15-25% commission savings vs OTAs)
• OTAs (Booking.com, Expedia) — Use for demand generation and low-occupancy periods, maintain parity compliance
• Metasearch (Google Hotels, TripAdvisor) — Bid management agent adjusts CPC based on conversion probability
• Group/corporate — Displacement analysis — only accept group blocks when group rate * nights > displaced transient revenue

2. Intelligent Booking & Concierge Agent

A booking concierge agent handles the entire guest journey from initial inquiry to post-stay feedback. Unlike a simple chatbot, it has access to the PMS, CRM, and local knowledge to make contextual, personalized recommendations.

Conversational Booking Flow

from typing import Optional

class BookingConciergeAgent:
    """AI agent for intelligent travel booking and concierge."""

    def __init__(self, pms, crm, knowledge_base, llm):
        self.pms = pms  # Property Management System
        self.crm = crm
        self.kb = knowledge_base
        self.llm = llm

    async def handle_inquiry(self, guest_message: str,
                              session: dict) -> dict:
        """Process a guest inquiry with full context."""
        # Build context
        guest_profile = None
        if session.get('guest_id'):
            guest_profile = self.crm.get_profile(session['guest_id'])

        # Classify intent
        intent = self._classify_intent(guest_message)

        if intent == 'booking_inquiry':
            return await self._handle_booking(guest_message, guest_profile, session)
        elif intent == 'modification':
            return await self._handle_modification(guest_message, guest_profile, session)
        elif intent == 'local_recommendation':
            return await self._handle_recommendation(guest_message, guest_profile)
        elif intent == 'complaint':
            return await self._handle_complaint(guest_message, guest_profile, session)
        elif intent == 'amenity_request':
            return await self._handle_amenity(guest_message, guest_profile, session)
        else:
            return await self._general_response(guest_message, guest_profile)

    async def _handle_booking(self, message: str, profile: dict,
                               session: dict) -> dict:
        """Handle a booking inquiry with upsell opportunities."""
        # Extract dates and preferences from natural language
        parsed = self.llm.extract({
            'check_in': 'date',
            'check_out': 'date',
            'guests': 'int',
            'room_preference': 'string',
            'budget': 'float',
            'special_requests': 'string'
        }, message)

        # Check availability
        available_rooms = self.pms.check_availability(
            check_in=parsed['check_in'],
            check_out=parsed['check_out'],
            guests=parsed.get('guests', 2)
        )

        if not available_rooms:
            # Offer alternatives (nearby dates, sister properties)
            alternatives = self._find_alternatives(parsed)
            return {
                'response': self._format_alternatives(alternatives),
                'action': 'show_alternatives'
            }

        # Personalized room selection
        if profile:
            # Returning guest: use preferences
            recommended = self._rank_rooms_for_guest(
                available_rooms, profile, parsed
            )
        else:
            recommended = self._rank_rooms_default(
                available_rooms, parsed
            )

        # Upsell detection
        upsells = self._identify_upsells(
            recommended[0], parsed, profile
        )

        response = self._format_booking_options(
            recommended[:3], upsells, parsed
        )

        return {
            'response': response,
            'rooms': recommended[:3],
            'upsells': upsells,
            'action': 'present_options',
            'booking_ready': True
        }

    def _identify_upsells(self, room: dict, parsed: dict,
                           profile: dict) -> list:
        """Identify relevant upsell opportunities."""
        upsells = []
        nights = (parsed['check_out'] - parsed['check_in']).days

        # Room upgrade (if marginal cost is low)
        upgrade = self._get_upgrade_option(room)
        if upgrade and upgrade['price_diff'] < room['rate'] * 0.25:
            upsells.append({
                'type': 'room_upgrade',
                'description': f"Upgrade to {upgrade['name']}",
                'price': f"+${upgrade['price_diff']}/night",
                'value_prop': upgrade['benefits']
            })

        # Package deals
        if nights >= 3:
            upsells.append({
                'type': 'spa_package',
                'description': "Relaxation Package",
                'price': f"${89 * nights}",
                'value_prop': "Daily spa credit + late checkout"
            })

        # Anniversary/birthday detection
        if profile and self._has_upcoming_celebration(profile):
            upsells.append({
                'type': 'celebration',
                'description': "Celebration Package",
                'price': "$149",
                'value_prop': "Champagne, flowers, room decoration"
            })

        return upsells

3. Guest Personalization Engine

The personalization agent builds a 360-degree guest profile across stays, channels, and properties to deliver tailored experiences that drive loyalty and direct bookings.

Profile Building & Application

class GuestPersonalizationAgent:
    """AI agent for personalized guest experiences."""

    def __init__(self, crm, pms, preferences_model):
        self.crm = crm
        self.pms = pms
        self.model = preferences_model

    def build_stay_brief(self, reservation_id: str) -> dict:
        """Generate a personalized brief for an incoming guest."""
        reservation = self.pms.get_reservation(reservation_id)
        guest = self.crm.get_profile(reservation['guest_id'])

        # Compile all known preferences
        preferences = {
            'room': self._extract_room_preferences(guest),
            'dining': self._extract_dining_preferences(guest),
            'activities': self._extract_activity_preferences(guest),
            'communication': self._extract_comm_preferences(guest),
            'special_needs': guest.get('special_needs', [])
        }

        # Previous stay insights
        past_stays = self.crm.get_stay_history(guest['id'])
        insights = self._analyze_stay_history(past_stays)

        # Predictive preferences (what they'll likely want)
        predicted = self.model.predict_preferences(
            guest_profile=guest,
            stay_context={
                'purpose': reservation.get('purpose', 'leisure'),
                'season': self._get_season(reservation['check_in']),
                'day_of_week': reservation['check_in'].weekday(),
                'length_of_stay': reservation['nights'],
                'rate_paid': reservation['rate'],
                'companions': reservation.get('companions', [])
            }
        )

        # Generate actionable brief for staff
        brief = {
            'guest_name': guest['name'],
            'loyalty_tier': guest.get('tier', 'new'),
            'total_stays': len(past_stays),
            'total_revenue': sum(s['total_revenue'] for s in past_stays),
            'known_preferences': preferences,
            'predicted_preferences': predicted,
            'room_setup': self._generate_room_setup(preferences, predicted),
            'welcome_amenity': self._select_welcome_amenity(guest, reservation),
            'dining_suggestions': self._get_dining_suggestions(
                preferences['dining'], reservation
            ),
            'potential_issues': self._identify_potential_issues(
                guest, reservation, past_stays
            ),
            'upsell_opportunities': self._identify_upsell_opportunities(
                guest, reservation
            )
        }

        return brief

    def _generate_room_setup(self, preferences: dict,
                              predicted: dict) -> list:
        """Generate specific room setup instructions."""
        setup = []

        # Temperature
        if preferences['room'].get('preferred_temp'):
            setup.append(f"Set thermostat to {preferences['room']['preferred_temp']}°F")

        # Pillow preferences
        if preferences['room'].get('pillow_type'):
            setup.append(f"Place {preferences['room']['pillow_type']} pillows")

        # Minibar customization
        if preferences['dining'].get('allergies'):
            setup.append(f"Remove {', '.join(preferences['dining']['allergies'])} items from minibar")

        # Predicted needs
        if predicted.get('will_need_workspace'):
            setup.append("Set up desk area with extra outlets and monitor stand")

        if predicted.get('early_riser'):
            setup.append("Place coffee machine supplies prominently")

        return setup

4. Operations Optimization

The operations agent manages the complex choreography of hotel operations — housekeeping schedules, staff allocation, inventory management, and energy optimization.

Smart Housekeeping Scheduling

class HotelOperationsAgent:
    """AI agent for hotel operations optimization."""

    def optimize_housekeeping(self, hotel_id: str, date: str) -> dict:
        """Generate optimal housekeeping schedule."""
        # Get room status and priorities
        rooms = self.pms.get_room_status(hotel_id, date)
        check_ins = [r for r in rooms if r['status'] == 'checking_in']
        check_outs = [r for r in rooms if r['status'] == 'checking_out']
        stayovers = [r for r in rooms if r['status'] == 'stayover']
        vip_rooms = [r for r in rooms if r.get('vip')]

        # Get available housekeeping staff
        staff = self.get_available_staff(hotel_id, date, role='housekeeping')
        avg_clean_time = {
            'checkout': 35,    # minutes
            'stayover': 20,
            'vip_checkout': 45,
            'vip_stayover': 30
        }

        # Priority ordering
        priority_queue = []

        # 1. VIP arrivals first (must be ready by check-in time)
        for room in sorted(vip_rooms, key=lambda r: r.get('eta', '15:00')):
            priority_queue.append({
                'room': room['number'],
                'type': 'vip_checkout' if room['status'] == 'checking_out' else 'vip_stayover',
                'deadline': room.get('eta', '14:00'),
                'priority': 1
            })

        # 2. Early arrivals (pre-14:00 check-in requests)
        for room in check_ins:
            if room.get('early_checkin') and room not in vip_rooms:
                priority_queue.append({
                    'room': room['number'],
                    'type': 'checkout',
                    'deadline': room.get('eta', '12:00'),
                    'priority': 2
                })

        # 3. Regular checkouts (ready by standard check-in time)
        for room in check_outs:
            if room not in vip_rooms and not room.get('early_checkin'):
                priority_queue.append({
                    'room': room['number'],
                    'type': 'checkout',
                    'deadline': '15:00',
                    'priority': 3
                })

        # 4. Stayovers (flexible timing)
        for room in stayovers:
            if room not in vip_rooms:
                # Check DND status and guest preferences
                if room.get('dnd'):
                    continue
                priority_queue.append({
                    'room': room['number'],
                    'type': 'stayover',
                    'deadline': '17:00',
                    'priority': 4,
                    'preferred_time': room.get('preferred_clean_time')
                })

        # Assign to staff using constraint optimization
        assignments = self._assign_rooms_to_staff(
            priority_queue, staff, avg_clean_time
        )

        # Floor clustering (minimize walking time)
        for assignment in assignments:
            assignment['rooms'] = self._cluster_by_floor(
                assignment['rooms']
            )

        return {
            'schedule': assignments,
            'total_rooms': len(priority_queue),
            'estimated_completion': self._estimate_completion(
                assignments, avg_clean_time
            ),
            'capacity_utilization': f"{len(priority_queue) / (len(staff) * 16) * 100:.0f}%"
        }

Energy Management

Hotels spend 3-6% of revenue on energy. The agent optimizes HVAC, lighting, and water heating based on occupancy patterns:

• Vacant room setback — Reduce HVAC to economy mode 30 minutes after checkout, restore 1 hour before check-in
• Predictive pre-conditioning — Use booking data and historical patterns to pre-cool/heat rooms, avoiding energy spikes
• Common area optimization — Adjust lobby, restaurant, and meeting room climate based on real-time occupancy sensors
• Peak demand management — Shift non-critical loads (laundry, water heating) to off-peak hours to reduce demand charges

5. Review & Reputation Management

Online reviews directly impact revenue — a 1-star increase on TripAdvisor correlates with a 5-9% increase in revenue (Cornell Hospitality). The review agent monitors, analyzes, and responds to reviews across all platforms in real time.

Sentiment Analysis Pipeline

class ReviewManagementAgent:
    """AI agent for hospitality review management."""

    def __init__(self, llm, review_sources, alert_system):
        self.llm = llm
        self.sources = review_sources
        self.alerts = alert_system

    def analyze_review(self, review: dict) -> dict:
        """Deep analysis of a guest review."""
        analysis = self.llm.analyze(f"""
        Analyze this hotel review:
        Rating: {review['rating']}/5
        Text: {review['text']}

        Extract:
        1. Overall sentiment (positive/mixed/negative)
        2. Specific aspects mentioned (room, service, food, location, cleanliness, value)
        3. Aspect-level sentiment for each
        4. Specific staff mentions (positive or negative)
        5. Actionable issues that need addressing
        6. Guest type indicators (business, family, couple, solo)
        7. Price sensitivity indicators
        """)

        # Urgency scoring
        urgency = 0
        if review['rating'] <= 2:
            urgency += 40
        if 'health' in review['text'].lower() or 'safety' in review['text'].lower():
            urgency += 30
        if 'never again' in review['text'].lower() or 'worst' in review['text'].lower():
            urgency += 20
        if review.get('platform') in ['google', 'tripadvisor']:  # High visibility
            urgency += 10

        # Alert if critical
        if urgency >= 60:
            self.alerts.send(
                level='critical',
                message=f"Critical review on {review['platform']}: {review['text'][:100]}...",
                assignee='gm'
            )

        return {
            **analysis,
            'urgency_score': urgency,
            'response_priority': 'immediate' if urgency >= 60 else 'same_day' if urgency >= 30 else 'standard',
            'suggested_response': self._generate_response(review, analysis)
        }

    def _generate_response(self, review: dict, analysis: dict) -> str:
        """Generate a personalized, authentic response."""
        guidelines = {
            'positive': 'Thank genuinely, reference specific details they mentioned, invite back',
            'mixed': 'Acknowledge the positive, address concerns specifically, explain what you are doing to improve',
            'negative': 'Apologize sincerely, take specific accountability, offer to make it right offline, provide direct contact'
        }

        response = self.llm.generate(f"""
        Write a management response to this review.
        Guidelines: {guidelines[analysis['sentiment']]}

        Rules:
        - Be specific (reference their actual experience, not generic platitudes)
        - Keep it under 150 words
        - Sound human, not corporate
        - If negative: acknowledge, don't make excuses
        - Include GM name and direct contact for negative reviews
        - Never argue with the guest
        - Never offer compensation publicly (handle offline)

        Review: {review['text']}
        Analysis: {analysis}
        """)

        return response

    def generate_insights_report(self, hotel_id: str,
                                  period_days: int = 30) -> dict:
        """Generate actionable insights from review analysis."""
        reviews = self._get_reviews(hotel_id, days=period_days)
        analyses = [self.analyze_review(r) for r in reviews]

        # Aggregate by aspect
        aspects = {}
        for a in analyses:
            for aspect, sentiment in a.get('aspects', {}).items():
                if aspect not in aspects:
                    aspects[aspect] = {'positive': 0, 'negative': 0, 'mentions': []}
                aspects[aspect][sentiment] += 1
                aspects[aspect]['mentions'].append(a.get('text_excerpt', ''))

        # Identify trending issues
        trending_issues = [
            {'aspect': k, 'negative_rate': v['negative'] / (v['positive'] + v['negative'] + 0.01)}
            for k, v in aspects.items()
            if v['negative'] > 3
        ]
        trending_issues.sort(key=lambda x: -x['negative_rate'])

        return {
            'period': f'{period_days} days',
            'total_reviews': len(reviews),
            'avg_rating': np.mean([r['rating'] for r in reviews]),
            'sentiment_distribution': {
                'positive': len([a for a in analyses if a['sentiment'] == 'positive']),
                'mixed': len([a for a in analyses if a['sentiment'] == 'mixed']),
                'negative': len([a for a in analyses if a['sentiment'] == 'negative'])
            },
            'top_positives': sorted(aspects.items(), key=lambda x: -x[1]['positive'])[:3],
            'top_issues': trending_issues[:5],
            'staff_mentions': self._extract_staff_mentions(analyses),
            'competitor_mentions': self._extract_competitor_mentions(analyses)
        }

6. Predictive Maintenance

Equipment failures in hotels don't just cost money to fix — they cost guest satisfaction and reviews. An HVAC failure on the hottest day of the year, a broken elevator during a conference, or plumbing issues in a VIP suite can be catastrophic. The maintenance agent predicts failures before they happen.

IoT-Driven Prediction

class MaintenanceAgent:
    """AI agent for hotel predictive maintenance."""

    def __init__(self, sensor_store, maintenance_model, work_order_system):
        self.sensors = sensor_store
        self.model = maintenance_model
        self.work_orders = work_order_system

    def daily_assessment(self, hotel_id: str) -> dict:
        """Run daily predictive maintenance assessment."""
        assets = self._get_monitored_assets(hotel_id)
        alerts = []

        for asset in assets:
            readings = self.sensors.get_recent(asset['id'], hours=24)

            # Anomaly detection
            anomaly_score = self.model.predict_anomaly(
                asset_type=asset['type'],
                readings=readings,
                age_months=asset['age_months'],
                last_service=asset['last_service_date']
            )

            # Remaining useful life estimation
            rul = self.model.predict_rul(
                asset_type=asset['type'],
                readings=readings,
                maintenance_history=asset['maintenance_history']
            )

            if anomaly_score > 0.7 or rul['days'] < 14:
                priority = 'critical' if anomaly_score > 0.9 or rul['days'] < 3 else 'high' if anomaly_score > 0.8 or rul['days'] < 7 else 'medium'

                alerts.append({
                    'asset': asset['name'],
                    'location': asset['location'],
                    'type': asset['type'],
                    'anomaly_score': anomaly_score,
                    'remaining_life_days': rul['days'],
                    'likely_failure_mode': rul['failure_mode'],
                    'priority': priority,
                    'guest_impact': self._assess_guest_impact(asset),
                    'estimated_repair_cost': rul['estimated_cost'],
                    'vs_emergency_cost': rul['emergency_cost']
                })

        # Auto-create work orders for critical items
        for alert in alerts:
            if alert['priority'] in ['critical', 'high']:
                self.work_orders.create(
                    asset_id=alert['asset'],
                    priority=alert['priority'],
                    description=f"Predictive: {alert['likely_failure_mode']}. "
                               f"RUL: {alert['remaining_life_days']} days. "
                               f"Anomaly score: {alert['anomaly_score']:.2f}",
                    estimated_cost=alert['estimated_repair_cost']
                )

        return {
            'assets_monitored': len(assets),
            'alerts': alerts,
            'critical': len([a for a in alerts if a['priority'] == 'critical']),
            'estimated_savings': sum(
                a['vs_emergency_cost'] - a['estimated_repair_cost']
                for a in alerts if a['priority'] in ['critical', 'high']
            )
        }

ROI Calculator

Here's what a mid-size hotel (300 rooms, $40M annual revenue) can expect:

Platform Comparison

Common Mistakes

• Optimizing for occupancy instead of RevPAR — A 95% occupancy at $100/night is worse than 80% at $140/night. Always optimize for revenue per available room, not fill rate.
• Ignoring displacement — Accepting a 200-room group block at a discount might displace higher-paying transient guests. The agent must model opportunity cost.
• Over-automating guest interactions — AI should handle routine queries (wifi password, checkout time) but route emotional or complex situations to staff. A frustrated guest wants a human, not a chatbot.
• Neglecting data quality — Revenue management models are only as good as their data. Ensure PMS data is clean: correct room type mappings, accurate market segments, proper cancellation tracking.
• Rate parity violations — OTAs actively monitor rate parity. An AI agent that drops direct rates below OTA rates can trigger penalties. Build parity compliance into the pricing logic.

Getting Started: Weekend MVP

1. Day 1 morning — Export 24 months of booking data (reservation date, stay date, room type, rate, channel, cancellation). Clean it: handle no-shows, group blocks, complimentary stays.
2. Day 1 afternoon — Build a demand forecast: predict occupancy by room type and date using features (day-of-week, season, events, booking pace). LightGBM works great here.
3. Day 2 morning — Create the pricing logic: base rate * demand multiplier * scarcity factor * competitor adjustment. Start conservative (max 15% swing from current rates).
4. Day 2 afternoon — Set up a daily report: recommended rates vs. current rates, with expected occupancy and revenue impact. Let the revenue manager review and approve for 2 weeks before automating.

This MVP alone can improve RevPAR by 3-5% within the first month by eliminating the most obvious mispricing — like keeping rates static when a major event is happening nearby.