himap-travel

name	himap-travel
title	HiMAP-Travel: Hierarchical Multi-Agent Planning for Long-Horizon Constrained Travel
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2603.04750
keywords	["Agent Planning","Long-horizon Tasks","Constraint Management","Multi-agent Coordination","Tool Use"]
description	Solves long-horizon planning problems with global constraints by decoupling planning into strategic (resource allocation) and tactical (execution) levels. Prevents constraint drift through synchronized state tracking and cooperative bargaining.

HiMAP-Travel: Preventing Constraint Drift in Multi-Day Planning Through Hierarchical Decomposition

Long-horizon planning with LLM agents fails when maintaining global constraints across many steps. As planning progresses and intermediate outputs accumulate in context, the model's attention to initial constraints diminishes—budget allocations drift, resource conflicts emerge, and logical inconsistencies cascade. This constraint drift is invisible until terminal failure, making multi-day itinerary generation particularly brittle.

HiMAP-Travel solves this through hierarchical decomposition: a strategic coordinator allocates resources across planning horizons while tactical executors operate independently on sub-problems. This limits effective context length per executor and forces explicit constraint tracking through synchronized state, preventing attention drift.

Core Concept

Decompose long-horizon planning (e.g., 7-day trip) into two levels:

1. Strategic Coordinator: Allocates global resources (total budget, required destinations, daily allocations) and monitors constraint compliance atomically
2. Tactical Executors: Day-level planners work in isolation with bounded context, receiving daily budgets and constraints as clear inputs

The coordinator acts as a transaction monitor: executors propose plans, the coordinator validates against global state, and if infeasible, triggers resource reallocation rather than regeneration.

Architecture Overview

• Coordinator Module: Maintains global state (Σ), validates constraint compliance, handles resource reallocation
• Executor Modules: Specialized day-planners receiving daily context windows with isolated state
• Synchronized Global State (Σ): Tracks budget, visited venues (fuzzy-matched), transportation modes, time constraints
• Checkpoint/Rollback Protocol: Executors can retry with adjusted allocations without regenerating entire sub-plans
• Unified Policy Network: Single GRPO-trained model π_θ with role-conditioned prompts for both coordinator and executor roles

Implementation Steps

Create a hierarchical planning system with explicit state synchronization. The coordinator routes between executors and maintains consistency.

Coordinator State Management

Track global constraints and validate executor proposals:

# Global state maintained by coordinator
class GlobalPlanningState:
    def ():
        .total_budget = total_budget
        .num_days = num_days
        .remaining_budget = total_budget
        .required_venues = (required_venues)
        .visited_venues = ()
        .day_allocations = {}  
        .transportation_modes = []  
        .violated_constraints = []

     ():
        
         .remaining_budget < amount:
             InfeasibleAllocation()
        .remaining_budget -= amount
        .day_allocations[day] = amount

     ():
        
        
        matched = fuzzy_match_venue(venue_name, .visited_venues, threshold=)
         matched:
             , 
         , 

     ():
        
        issues = []
        venues_in_plan = plan_dict.get(, [])
        daily_cost = plan_dict.get(, )

        
         daily_cost > .day_allocations.get(day, ):
            issues.append()

        
         venue  venues_in_plan:
            valid, reason = .validate_venue_addition(venue)
              valid:
                issues.append(reason)
            :
                .visited_venues.add(venue)

        
        transport = plan_dict.get()
         transport  .transportation_modes  transport != .transportation_modes[-]:
            issues.append()

         (issues) == , issues