菜单
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.
默认使用会先检查来源的 Prompt；你也可以切换为直接命令，或下载本地副本。
决定是否安装前，请先阅读 SKILL.md，以及 SkillsMP 当前展示的配套文件。
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
直接命令不会经过审查 Prompt；运行前请先检查来源。
npx skills add https://github.com/ADu2021/skillXiv --skill himap-travel命令会保持在同一行。复制前请横向滚动并检查完整内容。
想先保存到本地？可下载 SkillsMP 当前能够提供的文件。
基于 SOC 职业分类
正在显示 SKILL.md
| 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. |
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.
Decompose long-horizon planning (e.g., 7-day trip) into two levels:
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.
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
Coordinator-Executor Communication
The coordinator orchestrates planning rounds and handles infeasibility:
def hierarchical_planning_loop(coordinator_model, executor_models, global_state, num_days):
"""
coordinator_model: LLM trained to allocate resources
executor_models: day-level planners (can be same model with different prompts)
global_state: GlobalPlanningState instance
num_days: total planning horizon
"""
all_daily_plans = []
for day in range(1, num_days + 1):
# Step 1: Coordinator decides daily budget allocation
coordinator_prompt = f"""
You are a travel budget coordinator. Total budget: ${global_state.total_budget}
Remaining: ${global_state.remaining_budget}
Days remaining: {num_days - day + 1}
Required venues not yet visited: {global_state.required_venues - global_state.visited_venues}
Allocate budget for day {day}. Return JSON: {{"daily_budget": <number>, "day_notes": "<strategy>"}}
"""
coord_response = coordinator_model.generate(coordinator_prompt)
daily_budget = json.loads(coord_response)['daily_budget']
# Allocate globally
global_state.allocate_budget_to_day(day, daily_budget)
# Step 2: Executor plans for this day
executor_prompt = f"""
You are a travel executor planning day {day}/{num_days}.
Daily budget: ${daily_budget}
Required venues to eventually visit: {global_state.required_venues - global_state.visited_venues}
Previously visited: {list(global_state.visited_venues)}
Generate a detailed itinerary for today. Return JSON: {{"venues": [...], "total_cost": <number>, "transport_mode": "<mode>"}}
"""
max_retries = 3
for attempt in range(max_retries):
executor_response = executor_models[day].generate(executor_prompt)
day_plan = json.loads(executor_response)
# Validate against global state
valid, issues = global_state.validate_executor_output(day, day_plan)
if valid:
all_daily_plans.append(day_plan)
break
else:
if attempt < max_retries - 1:
# Replan with constraint feedback
executor_prompt += f"\n\nConstraint violations: {', '.join(issues)}\nRevise plan to fix these issues."
else:
# Coordinator re-allocates resources
coordinator_prompt += f"\nDay {day} executor failed: {issues}. Re-allocate resources."
coord_response = coordinator_model.generate(coordinator_prompt)
new_budget = json.loads(coord_response)['daily_budget']
global_state.day_allocations[day] = new_budget
executor_prompt = executor_prompt.replace(f"${daily_budget}", f"${new_budget}")
return all_daily_plans
Executor Role-Conditioned Inference
Use the same model for both coordinator and executor via system prompt conditioning:
def get_system_prompt(role, context):
"""Role-conditioned system prompts for unified policy"""
if role == "coordinator":
return """You are a strategic travel budget coordinator. Your job is to allocate
global resources across the planning horizon while respecting constraints. Think
systemically about resource distribution and constraint satisfaction."""
elif role == "executor":
return """You are a tactical travel planner executing a single day of an itinerary.
You have a daily budget and must select venues and routes that fit within constraints.
Propose detailed, feasible daily plans."""
return ""
Hyperparameters:
When to Apply:
When NOT to Apply:
Key Pitfalls:
Integration Notes: Works as a planning wrapper around any LLM; requires structured JSON output from both coordinator and executors; rollback mechanism needs version control of global state.
Evidence: Achieves 52.65% final pass rate on TravelPlanner benchmark (+8.67pp over sequential baselines); provides 2.63x speedup through executor parallelization; maintains constraint satisfaction across 7-day itineraries with >95% global consistency.
Reference: https://arxiv.org/abs/2603.04750