Long-horizon agents are autonomous systems designed to execute extended multi-step tasks spanning hundreds or thousands of actions while maintaining coherent goal pursuit. These agents must cope with context drift, compounding errors, sparse feedback signals, and the need to recover gracefully from failures deep into execution.

Most current LLM-based agents work well for short tasks of 5-20 steps. However, real-world problems — software engineering projects, scientific experiments, complex data analysis — often require sustained effort over hundreds of steps. Long-horizon agents address the fundamental challenge of maintaining task coherence and making progress over extended execution periods where the probability of encountering errors approaches certainty.

The key insight driving recent research is that naive flat planning fails at scale. Instead, long-horizon agents require hierarchical decomposition, persistent memory, proactive validation, and robust error recovery mechanisms.

InternAgent 1.5 provides a unified framework for long-horizon autonomous scientific discovery. Its architecture comprises three coordinated subsystems for generation, verification, and evolution, supported by deep research capabilities, solution optimization, and long-horizon memory. The system operates continuously across extended discovery cycles while maintaining coherent and improving behavior, achieving leading performance on GAIA, HLE, GPQA, and FrontierScience benchmarks.

The Plan-and-Act framework separates high-level planning from low-level execution using a dedicated Planner trained on synthetic data from ground-truth trajectories, paired with an Executor that translates plans into actions. This architecture achieves 57.58% success on WebArena-Lite, with dynamic replanning boosting success by +34 percentage points over flat ReAct approaches.

ELHPlan introduces action chains as minimal planning units that bind multi-step action sequences to explicit sub-goal intentions. The system follows a cyclical process: construct chains with dynamic length via LLM prompts with shared memory, proactively validate for feasibility and conflicts, refine issues, and execute. This reduces token usage by 30-40% and planning time by 9-26% on challenging benchmarks while maintaining success rates.

Long-horizon agents decompose tasks into hierarchical structures where high-level plans specify abstract goals and low-level executors handle concrete actions. This separation allows the planner to reason about strategy without getting lost in implementation details.

# Hierarchical planning for long-horizon tasks
class LongHorizonAgent:
    def __init__(self, planner, executor, memory):
        self.planner = planner       # High-level strategic planning
        self.executor = executor     # Low-level action execution
        self.memory = memory         # Persistent shared state
 
    def execute_task(self, goal):
        plan = self.planner.decompose(goal)
 
        for subgoal in plan.subgoals:
            # Create action chain for this subgoal
            chain = self.planner.create_action_chain(subgoal, self.memory)
 
            # Proactive validation before execution
            issues = self.planner.validate(chain, self.memory)
            if issues:
                chain = self.planner.refine(chain, issues)
 
            # Execute with checkpointing
            for action in chain:
                result = self.executor.step(action)
                self.memory.checkpoint(action, result)
 
                if result.failed:
                    chain = self.planner.replan(subgoal, self.memory)
                    break
 
        return self.memory.get_final_result()

Over long execution sequences, the agent's working context can drift from the original goal. Techniques to combat this include:

• Shared memory modules that persist the original goal and high-level plan
• Periodic goal re-grounding where the agent explicitly checks alignment with objectives
• Spatio-temporal planning that maintains awareness of both spatial and temporal task structure
• Episodic recall from memory of similar past situations

Structured plan representations and self-reflective mechanisms ensure the agent stays on track. REMAC (Self-Reflective Multi-Agent Collaboration) implements continuous pre/post-condition checks that detect goal drift, feeding reflections into LLMs for plan evolution with dynamic task allocation.

Action chains with intention-bound checkpoints and “replan” placeholders enable recovery under partial observability. The agent records not just what it did, but why, enabling intelligent recovery rather than blind restart. ELHPlan's validation-refinement loops provide targeted fixes while minimizing full replanning.

Long-running tasks will inevitably encounter errors. Effective strategies include:

• Proactive validation — checking feasibility before execution
• Localized replanning — fixing only the affected portion of the plan
• Rollback checkpoints — reverting to the last known good state
• Error pattern learning — recognizing and avoiding previously encountered failure modes

• Error compounding — small per-step error rates become catastrophic over hundreds of steps
• Credit assignment — determining which step caused a failure deep in execution
• Resource management — context windows and compute budgets are finite
• Evaluation difficulty — benchmarks for truly long-horizon tasks are scarce and expensive
• Cross-domain transfer — planning strategies learned in one domain may not generalize

• InternAgent-1.5: Long-Horizon Autonomous Scientific Discovery (arXiv:2602.08990)
• ELHPlan: Action Chains for Long-Horizon Planning
• Emergent Mind: Long-Horizon Agent Planning

• Agent Trajectory Optimization
• Durable Execution for Agents
• Continual Learning Agents
• AI Scientist Agents