Building an End-to-End Flight and Hotel Booking Autonomous Assistant

1. The Combinatorial Reality of Travel Planning: Beyond Greedy Selection

Building an autonomous travel booking assistant represents one of the most challenging frontiers in applied artificial intelligence. While naive conversational bots can easily query a single flight endpoint and regurgitate raw JSON, true end-to-end travel synthesis is fundamentally an NP-hard Constraint Satisfaction Problem (CSP) coupled with a multi-objective optimization matrix.

In real-world business and leisure travel, itineraries are rarely dictated by a single variable such as "cheapest flight" or "closest hotel." Instead, a traveler’s decision space is governed by an interlocking web of hard constraints (inviolable physical and temporal bounds) and soft constraints (flexible personal preferences):

The Multi-Factor Constraint Matrix

* Hard Constraints: * Strict arrival deadlines (e.g., must arrive before Wednesday 5:00 PM for conference registration). * Origin and destination multi-airport clusters (e.g., NYC metro area: JFK, EWR, LGA -> SF Bay Area: SFO, OAK, SJC). * Maximum budget ceilings (e.g., total combined travel spend under \$1,400 USD). * Maximum commute threshold to event venues (e.g., under 25 minutes to Moscone Center during morning peak traffic). * Soft Constraints & Preferences: * Airline alliance loyalty (e.g., Star Alliance / United Airlines elite status preference). * Layover preferences (non-stop preferred over 1-stop connections). * Hotel brand loyalty & amenities (e.g., Marriott Bonvoy points, on-site fitness facility, complimentary breakfast, high-speed WiFi). * Refundable fare policies vs non-refundable basic economy.

Why Greedy Selection Inevitably Fails

A simple greedy heuristic that selects the absolute lowest-cost outbound flight will frequently trigger downstream systemic failures:

1. The Phantom Savings Trap: Booking a \$180 flight arriving at Oakland (OAK) at 11:30 PM rather than a \$240 flight to San Francisco (SFO) arriving at 4:00 PM appears optimal in isolation. However, late-night transit options from OAK to downtown San Francisco are limited to expensive ride-hail services (\$85 surge rate) and require an extra night of lodging (\$220), turning a \$60 flight saving into a \$245 net loss. 2. The Layover Tightrope: Selecting a flight with a 38-minute layover in Chicago O'Hare (ORD) during winter months introduces an intolerable 42% statistical probability of a missed connection, cascading into missed event registrations and unrecoverable hotel no-show penalties. 3. The Check-In Mismatch: Landing at 6:00 AM on a red-eye flight leaves the traveler stranded for 9 hours before standard hotel check-in (3:00 PM), requiring early check-in fees or complex luggage storage arrangements.

Because every choice in one domain (air transit) immediately recalibrates the feasible boundary conditions of another domain (lodging and ground mobility), an autonomous agent must operate as a stateful graph coordinator capable of parallel discovery, speculative branch evaluation, and deterministic backtracking.

2. Multi-Agent Swarm Topology: Orchestrating the Travel Pipeline

To resolve this combinatorial space cleanly without context window saturation or hallucinated parameters, production architectures partition responsibilities across a specialized multi-agent topology. Rather than forcing a single monolithic LLM prompt to query APIs, balance budgets, and format itineraries simultaneously, we implement a Four-Node Directed Agent Graph:

1. Intake & Constraint Parsing Agent: Ingests unstructured conversational text, resolves ambiguous regional references (e.g., "Bay Area" -> ['SFO', 'OAK', 'SJC']), aligns dates against absolute calendar ISO strings, and outputs a strictly typed TravelParameters model. 2. Flight Discovery Worker: Manages asynchronous calls to Global Distribution Systems (GDS like Amadeus, Sabre) or search scrapers (Google Flights via SerpApi). It groups multi-leg journeys, parses fare conditions (Basic Economy vs Main Cabin), and flags carry-on restrictions. 3. Lodging & Geospatial Mobility Worker: Identifies hotels within a designated geographic polygon or radius of the traveler's focal point (e.g., Moscone Center). Crucially, it queries a Distance Matrix engine to compute actual peak-hour transit duration (walking or public transit) rather than deceptive straight-line distance. 4. Constraint Satisfaction & Pareto Synthesis Critic: Constructs cartesian combinations of available flights and accommodations. It computes a global utility score for each pair based on budget variance, flight quality, commute duration, and accommodation ratings. Branches violating hard limits are pruned immediately. 5. Human-in-the-Loop (HITL) Financial Checkout Gate: The terminal security boundary. Once the optimal itinerary is compiled, the agent freezes the proposal, verifies live inventory, and halts execution until the human user signs off on the exact financial charge.

3. Handling Real-Time Pricing Volatility, Inventory Churn, and Fare Locks

A fatal flaw in naive travel bot designs is the assumption that travel data is static. In reality, travel inventory operates under aggressive yield management and dynamic pricing algorithms:

* GDS Inventory Churn: Airline seat availability is categorized by alphanumeric "fare buckets" (e.g., Y, B, M, Q, V). As seats sell out globally, low-tier buckets vanish in seconds. * Cached vs Live Pricing Latency: Flight aggregators frequently return cached price snapshots that are 10 to 60 minutes old. A flight quoted at \$310 during discovery may return $440 upon attempting to create a booking session. * Session Expiration Windows: Booking engines typically provide a reservation hold window of only 10 to 20 minutes before releasing held inventory back to the global pool.

The 2-Phase Discovery and Re-Verification Architecture

To prevent quoting outdated prices to users or triggering failed payment transactions, production travel agents utilize a Decoupled Discovery and Atomic Re-Verification Pattern:

* Phase 1: Broad Discovery: Query aggregators (cache allowed) to assemble candidate lists (TTL \= 15 minutes). * Phase 2: Synthesis & Ranking: Pareto evaluation filters and ranks candidates down to the top-performing bundle. * Phase 3: Atomic Re-Verification (Pre-HITL): Execute an atomic GDS pricing call (e.g., Amadeus /v1/shopping/flight-offers/pricing). If the price is unchanged, proceed to the checkout gate. If the seat is sold out, blacklist the candidate and seamlessly backtrack to Candidate #2.

4. Complete Runnable Python Implementation

Below is the complete, production-ready Python implementation. It utilizes Pydantic V2 for rigid schema enforcement, implements mock API clients representing GDS and Distance Matrix endpoints, executes the multi-factor Pareto scoring algorithm, and enforces the strict Human-in-the-Loop checkout gate."""

Autonomous Flight and Hotel Booking Assistant

Tecvarsity AI Engineering Labs – Reference Implementation (Production Blueprint)

"""

from typing import List, Optional, Dict, Any, Tuple

from pydantic import BaseModel, Field, field_validator

from datetime import datetime, date, timedelta

from enum import Enum

import uuid

import math

# \============================================================================

# 1. DOMAIN SCHEMAS & DATA CONTRACTS (Pydantic V2)

# \============================================================================

class CabinClass(str, Enum):

ECONOMY \= "ECONOMY"

PREMIUM_ECONOMY \= "PREMIUM_ECONOMY"

BUSINESS \= "BUSINESS"

FIRST \= "FIRST"

class TransitMode(str, Enum):

WALKING \= "walking"

TRANSIT \= "transit"

DRIVING \= "driving"

class FlightSegment(BaseModel):

departure_airport: str \= Field(…, description="3-letter IATA code")

arrival_airport: str \= Field(…, description="3-letter IATA code")

departure_time: datetime

arrival_time: datetime

airline_code: str \= Field(…, description="2-letter IATA carrier code")

flight_number: str

cabin_class: CabinClass

aircraft_type: str \= "A321"

class FlightOffer(BaseModel):

offer_id: str

provider: str

total_price_usd: float

currency: str \= "USD"

outbound_segments: List[FlightSegment]

return_segments: Optional[List[FlightSegment]] \= None

refundable: bool \= False

baggage_included: bool \= True

quote_timestamp: datetime \= Field(default_factory=datetime.utcnow)

ttl_seconds: int \= 900 # 15-minute price validity

@property

def layover_count(self) -> int:

return max(0, len(self.outbound_segments) – 1)

@property

def total_duration_minutes(self) -> int:

if not self.outbound_segments:

return 0

start \= self.outbound_segments[0].departure_time

end \= self.outbound_segments[-1].arrival_time

return int((end – start).total_seconds() / 60)

@property

def final_arrival_time(self) -> datetime:

return self.outbound_segments[-1].arrival_time

class HotelOffer(BaseModel):

hotel_id: str

name: str

address: str

latitude: float

longitude: float

star_rating: float

nightly_rate_usd: float

total_stay_price_usd: float

check_in_date: date

check_out_date: date

free_cancellation: bool

cancellation_deadline: Optional[datetime] \= None

amenities: List[str] \= Field(default_factory=list)

commute_time_minutes_to_venue: Optional[int] \= None

commute_mode: Optional[TransitMode] \= None

class TravelConstraints(BaseModel):

origin_airports: List[str] \= Field(…, min_length=1)

destination_city: str

destination_airports: List[str] \= Field(…, min_length=1)

target_event_address: str

earliest_departure: datetime

latest_arrival_deadline: datetime

trip_end_date: date

max_total_budget_usd: float

max_layovers: int \= 1

preferred_alliance: Optional[str] \= None # e.g., 'Star Alliance'

max_commute_minutes_to_venue: int \= 30

require_free_cancellation_hotel: bool \= True

@field_validator("origin_airports", "destination_airports")

@classmethod

def validate_iata(cls, v: List[str]) -> List[str]:

for code in v:

if len(code) != 3 or not code.isupper():

raise ValueError(f"Airport code '{code}' must be a 3-letter uppercase IATA code.")

return v

class ItineraryPackage(BaseModel):

package_id: str \= Field(default_factory=lambda: f"PKG-{uuid.uuid4().hex[:8].upper()}")

flight: FlightOffer

hotel: HotelOffer

total_cost_usd: float

budget_variance_usd: float

composite_score: float

commute_summary: str

cancellation_guarantee: str

# \============================================================================

# 2. TOOL INTEGRATION WRAPPERS & APIS

# \============================================================================

class FlightSearchTool:

"""Mock connector simulating Amadeus Flight Offers & Google Flights API."""

@staticmethod

async def search_flights(

origins: List[str],

destinations: List[str],

departure_date: date,

cabin: CabinClass \= CabinClass.ECONOMY

) -> List[FlightOffer]:

now \= datetime.combine(departure_date, datetime.min.time())

return [

FlightOffer(

offer_id="FL-UA-101",

provider="Amadeus-GDS",

total_price_usd=420.00,

outbound_segments=[

FlightSegment(

departure_airport=origins[0],

arrival_airport=destinations[0],

departure_time=now + timedelta(hours=8),

arrival_time=now + timedelta(hours=14, minutes=30),

airline_code="UA",

flight_number="UA2415",

cabin_class=cabin

)

],

refundable=True,

baggage_included=True

),

FlightOffer(

offer_id="FL-DL-204",

provider="Google-Flights-Aggregator",

total_price_usd=310.00,

outbound_segments=[

FlightSegment(

departure_airport=origins[0],

arrival_airport="DEN",

departure_time=now + timedelta(hours=6),

arrival_time=now + timedelta(hours=9, minutes=15),

airline_code="DL",

flight_number="DL882",

cabin_class=cabin

),

FlightSegment(

departure_airport="DEN",

arrival_airport=destinations[0],

departure_time=now + timedelta(hours=11),

arrival_time=now + timedelta(hours=13, minutes=45),

airline_code="DL",

flight_number="DL1294",

cabin_class=cabin

)

],

refundable=False,

baggage_included=False

),

FlightOffer(

offer_id="FL-WN-509",

provider="Southwest-Direct",

total_price_usd=365.00,

outbound_segments=[

FlightSegment(

departure_airport=origins[0],

arrival_airport=destinations[-1] if len(destinations) > 1 else destinations[0],

departure_time=now + timedelta(hours=10),

arrival_time=now + timedelta(hours=16, minutes=45),

airline_code="WN",

flight_number="WN412",

cabin_class=cabin

)

],

refundable=True,

baggage_included=True

)

]

@staticmethod

async def verify_fare_lock(offer_id: str) -> Tuple[bool, float]:

"""Atomic pre-checkout call to verify seat availability and live fare."""

return True, 420.00 if offer_id \== "FL-UA-101" else 310.00

class HotelSearchTool:

"""Mock connector simulating Amadeus Hotel Search and Google Lodging APIs."""

@staticmethod

async def search_hotels(

city: str,

check_in: date,

check_out: date,

min_rating: float \= 4.0

) -> List[HotelOffer]:

nights \= (check_out – check_in).days or 1

return [

HotelOffer(

hotel_id="HTL-MAR-01",

name="San Francisco Marriott Marquis",

address="780 Mission St, San Francisco, CA 94103",

latitude=37.7854,

longitude=-122.4045,

star_rating=4.5,

nightly_rate_usd=249.00,

total_stay_price_usd=249.00 * nights,

check_in_date=check_in,

check_out_date=check_out,

free_cancellation=True,

cancellation_deadline=datetime.combine(check_in – timedelta(days=2), datetime.min.time()),

amenities=["High-Speed WiFi", "Fitness Center", "Meeting Rooms", "Restaurant"]

),

HotelOffer(

hotel_id="HTL-HYT-02",

name="Hyatt Regency San Francisco Downtown SOMA",

address="50 3rd St, San Francisco, CA 94103",

latitude=37.7871,

longitude=-122.4022,

star_rating=4.3,

nightly_rate_usd=219.00,

total_stay_price_usd=219.00 * nights,

check_in_date=check_in,

check_out_date=check_out,

free_cancellation=True,

cancellation_deadline=datetime.combine(check_in – timedelta(days=1), datetime.min.time()),

amenities=["WiFi", "Gym", "Breakfast Included"]

),

HotelOffer(

hotel_id="HTL-BUD-03",

name="Civic Center Motor Inn",

address="364 9th St, San Francisco, CA 94103",

latitude=37.7735,

longitude=-122.4112,

star_rating=3.2,

nightly_rate_usd=110.00,

total_stay_price_usd=110.00 * nights,

check_in_date=check_in,

check_out_date=check_out,

free_cancellation=False,

amenities=["WiFi"]

)

]

class GeospatialRoutingTool:

"""Computes realistic peak-hour commute times using Distance Matrix engines."""

@staticmethod

async def compute_venue_commute(

hotel_lat: float,

hotel_lng: float,

venue_address: str,

target_arrival_hour: int \= 9

) -> Tuple[int, TransitMode]:

venue_lat, venue_lng \= 37.7842, -122.4016

dlat \= math.radians(venue_lat – hotel_lat)

dlng \= math.radians(venue_lng – hotel_lng)

a \= math.sin(dlat / 2)2 + math.cos(math.radians(hotel_lat)) * math.cos(math.radians(venue_lat)) * math.sin(dlng / 2)2

c \= 2 * math.atan2(math.sqrt(a), math.sqrt(1 – a))

km \= 6371 * c

if km < 0.6:

return int(km * 12) + 4, TransitMode.WALKING

elif km < 2.5:

return int(km * 6) + 7, TransitMode.TRANSIT

else:

return int(km * 5) + 15, TransitMode.DRIVING

# \============================================================================

# 3. CONSTRAINT SATISFACTION & PARETO OPTIMIZATION ENGINE

# \============================================================================

class ItinerarySynthesisCritic:

"""Evaluates cross-domain travel bundles against hard and soft constraints."""

@classmethod

def evaluate_and_rank(

cls,

flights: List[FlightOffer],

hotels: List[HotelOffer],

constraints: TravelConstraints

) -> List[ItineraryPackage]:

feasible_packages: List[ItineraryPackage] \= []

for flight in flights:

if flight.layover_count > constraints.max_layovers:

continue

if flight.final_arrival_time > constraints.latest_arrival_deadline:

continue

for hotel in hotels:

if constraints.require_free_cancellation_hotel and not hotel.free_cancellation:

continue

commute_time \= hotel.commute_time_minutes_to_venue or 999

if commute_time > constraints.max_commute_minutes_to_venue:

continue

total_cost \= flight.total_price_usd + hotel.total_stay_price_usd

if total_cost > constraints.max_total_budget_usd:

continue

budget_ratio \= (constraints.max_total_budget_usd – total_cost) / constraints.max_total_budget_usd

flight_score \= 1.0 if flight.layover_count \== 0 else 0.65

if constraints.preferred_alliance and "UA" in flight.outbound_segments[0].airline_code:

flight_score += 0.15

commute_score \= max(0.2, 1.0 – (commute_time / 40.0))

hotel_score \= (hotel.star_rating / 5.0)

composite_score \= (

0.35 * budget_ratio +

0.25 * flight_score +

0.25 * commute_score +

0.15 * hotel_score

)

package \= ItineraryPackage(

flight=flight,

hotel=hotel,

total_cost_usd=round(total_cost, 2),

budget_variance_usd=round(constraints.max_total_budget_usd – total_cost, 2),

composite_score=round(composite_score, 4),

commute_summary=f"{commute_time} min via {hotel.commute_mode.value if hotel.commute_mode else 'transit'}",

cancellation_guarantee="Full Refund Available" if hotel.free_cancellation else "Non-refundable"

)

feasible_packages.append(package)

feasible_packages.sort(key=lambda x: x.composite_score, reverse=True)

return feasible_packages

# \============================================================================

# 4. HUMAN-IN-THE-LOOP (HITL) FINANCIAL CHECKOUT GATE

# \============================================================================

class FinancialCheckoutGate:

"""Strict authorization barrier preventing unauthorized automated charges."""

@staticmethod

def render_interactive_approval_card(package: ItineraryPackage) -> str:

f \= package.flight

h \= package.hotel

outbound \= f.outbound_segments[0]

card \= f"""

\================================================================================

TRAVEL ASSISTANT – ACTION REQUIRED: CHECKOUT APPROVAL

\================================================================================

PACKAGE IDENTIFIER : {package.package_id}

COMPOSITE SCORE : {package.composite_score} / 1.00 (Rank #1 Optimal Bundle)

TOTAL COST : \${package.total_cost_usd:.2f} USD (Under Budget by \${package.budget_variance_usd:.2f})

— [1. FLIGHT DETAILS] ——————————————————–

Airline / Flight : {outbound.airline_code}{outbound.flight_number} ({f.provider})

Route : {outbound.departure_airport} -> {f.outbound_segments[-1].arrival_airport}

Departure : {outbound.departure_time.strftime('%Y-%m-%d %H:%M')}

Arrival : {f.final_arrival_time.strftime('%Y-%m-%d %H:%M')}

Layovers : {f.layover_count} stop(s) | Total Travel Time: {f.total_duration_minutes // 60}h {f.total_duration_minutes % 60}m

Fare Conditions : {'Refundable' if f.refundable else 'Non-Refundable'} | Luggage: {'Included' if f.baggage_included else 'Carry-on only'}

Subtotal : \${f.total_price_usd:.2f} USD

— [2. HOTEL DETAILS] ———————————————————

Property Name : {h.name} ({h.star_rating} Stars)

Address : {h.address}

Commute to Venue : {package.commute_summary}

Check-In / Out : {h.check_in_date} to {h.check_out_date} ({(h.check_out_date – h.check_in_date).days} Nights)

Amenities : {', '.join(h.amenities[:3])}

Cancellation Policy: {package.cancellation_guarantee} (Until {h.cancellation_deadline.strftime('%Y-%m-%d') if h.cancellation_deadline else 'N/A'})

Subtotal : \${h.total_stay_price_usd:.2f} USD

— [3. PAYMENT AUTHORIZATION MANDATE] —————————————–

* In accordance with enterprise security invariants, this agent CANNOT charge

your card automatically.

* Seat hold reservation TTL expires in: 14 minutes 30 seconds.

To approve and complete booking, please submit confirmation:

[APPROVE PACKAGE {package.package_id}] or [REJECT / REQUEST ALTERNATIVE]

\================================================================================

"""

return card

@staticmethod

def execute_payment(package_id: str, user_confirmation_token: str) -> Dict[str, Any]:

"""Triggered only after valid cryptographic or explicit human confirmation."""

if not user_confirmation_token or not user_confirmation_token.startswith("CONFIRMED-"):

raise PermissionError("SECURITY ALERT: Missing or invalid human approval signature!")

return {

"booking_status": "CONFIRMED",

"confirmation_code": f"TV-BK-{uuid.uuid4().hex[:6].upper()}",

"amount_charged_usd": 1167.00,

"timestamp": datetime.utcnow().isoformat(),

"ticket_pnr": "6X8P9Q",

"hotel_voucher": "HTL-SF-88129"

}

5. The Human-in-the-Loop Financial Checkout Guardrails

The deployment of autonomous AI agents in e-commerce and travel booking environments introduces acute liability and financial exposure. Unlike an agent that generates text drafts or modifies calendar entries, an agent equipped with payment credentials executes irreversible, legally binding financial transactions.

To guarantee enterprise compliance and prevent runaway agent errors, we formalize the Three Pillars of Agentic Financial Governance:

1. Immutable Snapshot Freeze: The agent computes a cryptographic SHA-256 hash of the complete itinerary and leg pricing. Silent parameter mutation during execution is strictly forbidden. 2. Interactive Confirmation Card: An explicit UI boundary itemizing leg-by-leg charges, cancellation penalty deadlines, verified merchant identifiers, and fare hold TTLs. 3. Two-Phase Commit Authorization: * Phase 1 (Preparation & Hold): The agent contacts the vendor API (e.g., Amadeus /booking/flight-orders with draft=true), creating a temporary PNR reservation record that holds the seat and room inventory without initiating bank card capture. * Phase 2 (Commit & Capture): The transaction remains blocked until the user submits an explicit authorization token (e.g., via OAuth2 redirect, biometric prompt, or signed UI action). If the user does not respond within the 15-minute hold window, the transaction automatically aborts, releasing the hold without incurring fees.

6. Edge Cases, Failure Modes & Automated Recovery Strategies

In production travel environments, physical and administrative edge cases occur with predictable frequency:

| Failure Mode / Edge Case | Systemic Risk | Automated Agent Recovery Strategy | | :—- | :—- | :—- | | Airport Code Ambiguity | Booking flights to San Jose, Costa Rica (SJO) instead of San Jose, California (SJC). | Strict entity disambiguation using geographic bounding boxes and country-level validation matching target venue coordinates. | | Cross-Alliance Luggage Disconnect | Booking Leg 1 with Delta (SkyTeam) and Leg 2 with United (Star Alliance) on self-transfers. | Calculate a mandatory 3.5-hour transfer buffer for baggage reclaim and re-check, or enforce single-ticket interline agreements. | | Red-Eye Hotel Check-In Void | Landing at 05:30 AM; hotel reservation was booked for current calendar day with 15:00 check-in. | Detect early morning arrivals and prompt for previous-night booking extensions or negotiate pre-paid early arrival inventory. | | Dynamic Currency Volatility | Quoting in USD while international hotel charges in EUR or JPY with foreign transaction markups. | Bind exchange rates using European Central Bank daily feeds and display fixed currency conversion buffers (e.g., +3%). | | International Date Line Traversal | Transpacific flights departing Friday arriving Sunday, misaligning hotel check-in dates. | Utilize standard UTC epoch time offsets across all scheduling logic; translate local calendar dates only at UI boundaries. |