eaglet-planner

name	eaglet-planner
title	A Goal Without a Plan Is Just a Wish: Efficient Global Planner Training for Long-Horizon Agent Tasks
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2510.05608
keywords	["planning","long-horizon","reinforcement-learning","agent-training","executor-capability"]
description	Train efficient planners for long-horizon agent tasks using homologous consensus filtering to generate synthetic plans from strong LLMs and rule-based RL with executor capability rewards. Reduces training cost by 8x while maintaining state-of-the-art performance.

EAGLET: Efficient Planner Training via Synthetic Plan Generation

Long-horizon agent planning requires expensive manual annotation or extensive RL training. EAGLET generates synthetic high-quality plans from advanced LLMs without manual labeling, then refines them with specialized RL using executor feedback signals.

Core insight: strong planning comes from both good initial plans and learning from execution signals. By bootstrapping from LLM-generated plans and using executor capability as reward signal, you achieve sample-efficient training at 8x lower cost than traditional RL.

Core Concept

Homologous Consensus Filtering: Generate multiple candidate plans from a strong LLM and keep only those with high consensus across samples. This automatically filters out hallucinated or low-quality plans without human annotation.

Executor Capability Gain Reward: Reward signal based on whether executing the plan reveals new agent capabilities, not just whether tasks succeed. Encourages plans that push agent boundaries.

Architecture Overview

• Plan Synthesizer: Advanced LLM (GPT-4/Claude) generates diverse candidate plans
• Consensus Filter: Scores plans by agreement across multiple samples and baseline quality
• Executor Simulator: Simulates plan execution to estimate feasibility
• RL Trainer: Refines planner with capability-gain rewards

Implementation Steps

Stage 1: Synthetic Plan Generation with Consensus Filtering

Generate plans from strong LLM and filter by consensus:

def generate_consensus_plans(task, num_candidates=10, strong_llm='gpt-4'):
    """
    Generate diverse plans and keep only consensus-agreed ones.

    Args:
        task: description of agent task
        num_candidates: how many plan samples to generate
        strong_llm: which model to use for generation

    Returns:
        filtered_plans: high-confidence plans
    """

    # Generate diverse candidates
    candidates = []
    for i in range(num_candidates):
        temperature = 0.8  # Encourage diversity

        prompt = f"""
        For the task: 

        Generate a detailed step-by-step plan.
        Consider:
        - Necessary preconditions
        - High-level milestones
        - Dependency ordering
        - Executor constraints
        """

        plan = strong_llm.generate(
            prompt,
            temperature=temperature,
            max_tokens=
        )
        candidates.append(plan)

    
    consensus_scores = compute_plan_similarity(candidates)

    
    threshold = np.percentile(consensus_scores, )  
    filtered_plans = [
        candidates[i]  i  ((candidates))
         consensus_scores[i] >= threshold
    ]

     filtered_plans

 ():
    
    scores = []
     i, plan_i  (plans):
        
        steps_i = extract_plan_steps(plan_i)

        similarities = []
         j, plan_j  (plans):
             i != j:
                steps_j = extract_plan_steps(plan_j)
                sim = compute_step_similarity(steps_i, steps_j)
                similarities.append(sim)

        
        scores.append(np.mean(similarities))

     scores