Long-horizon tasks: why errors compound across many-step agents

The episodes (38)

Newest first. Each line is what that paper contributed to the question.

• The Model Built a Perfect Map of the Puzzle, Then Lost It

  The representation degrades over the course of long reasoning traces (~19k tokens), mirroring long-horizon agent drift. (41% → 73% optimal solutions)

• How a Robot Builds a Debugging Notebook It Can Read, Edit, and Hand to Another Robot

  Skills distilled from short-horizon debugging tasks are evaluated on multi-step household chores the system has never seen. (31% vs 4%)

• A 32B Open Model Matched Frontier Systems By Learning to Take Notes

  The benchmark games run up to 100,000 steps, making memory management the central bottleneck the paper targets. (2x-4x gains, same weights)

• Why Phone Agents Ace the Test and Crash on Your Actual Phone

  Stage three Agentic RL grades full multi-step task completion, requiring the agent to sustain memory and decisions across many screen transitions. (72% on real devices, roughly double the best open model)

• Why You Can't Fine-Tune Foresight Into an AI Agent

  The paper motivates foresight planning by the need for agents to avoid doomed multi-step paths in extended agentic tasks. (99%+ format adherence, ~0 capability gain)

• How a Tiny Model Too Weak to Plan Cuts a Bigger Agent's Hallucinations by 80%

  The paper's biggest measured gains appear on tasks beyond ten steps, where hallucination compounds and GILP's error contraction matters most. (80% fewer hallucinations)

• The Free Step-Level Grader Hiding in Every RL Training Run

  The paper specifically addresses the challenge that outcome rewards are uninformative across the many steps of long-horizon agent tasks. (0.87 vs 0.62 AUROC)

• A Free-Lunch Tweak That Lets a Tiny Agent Beat Frontier Giants

  The paper targets tasks with 40+ action steps where the reward signal is single and delayed until episode completion. (+22 points for <0.5% extra compute)

• Training an AI to Take Its Own Notes, So Its Future Self Works Better

  The paper frames the problem as a long-lifecycle agent spanning sequences of tasks, where early actions affect late rewards.

• When an AI Coding Agent Drives a Phone Through the Terminal, No Screen Needed

  The paper measures step efficiency across multi-step phone tasks and finds a large gap between oracle solutions (~3.7 steps) and live agents (~15 steps).

• Why a Flawless Demo Makes a Worse Computer-Using Agent, And the Fix

  The benchmark involves multi-step desktop workflows where early mistakes cascade, making distribution shift and error recovery critical.

• How a 7B Model Out-Investigates a 72B One by Choosing What to Look At

  The benchmark focus is hour-plus videos where passive frame-ingestion approaches hit hard memory and compute limits.

• Don't Kill the Loser: A Different Way to Handle Two AI Agents Colliding

  Agent transactions lasting minutes to hours make classical lock-and-abort protocols ruinously expensive compared to millisecond database transactions.

• Training a Tiny Model to Run the Plumbing Between an Agent and the World

  The benchmark tasks require dozens of sequential tool-use turns, making context accumulation and action redundancy the primary challenge the harness addresses.

• When Optimizing One GPU Kernel Quietly Breaks the Whole System

  Optimization campaigns run for 24+ hours, requiring shared state and failure recovery that single-context agents cannot sustain.

• Why Autonomous Research Agents Forget Their Own Lessons, and Arbor's Fix

  The core setting is 48-hour unsupervised research optimization runs, a quintessential long-horizon agentic task.

• AI Coding Agents Run a Marathon, and Fewer Than One in Three Finish

  The paper's central focus is evaluating whether agents can complete 40–400 human-hour software projects, not short bug fixes.

• Five Identical Worlds, One Swapped Model: What Happens When AI Agents Run for Fifteen Days

  The platform runs continuously for fifteen real-time days, explicitly designed to surface behaviors invisible in short-horizon benchmarks.

• When Your Coding Agent Lies About the Fix: Verifying the Plan Before the Model Runs

  The benchmarks target real GitHub issues requiring over an hour of human engineering effort — canonical long-horizon agent tasks.

• How an AI Agent Rewrites Its Own Tools, Without an Answer Key

  Gains concentrate on long-horizon multi-file repair tasks, and the agent sustains longer working sessions post-optimization.

• Teaching a Phone Agent to Reason Silently, And Keeping It Honest

  Tasks require sequencing 10-15+ actions across real Android apps, making per-step reasoning cost a practical bottleneck.

• When an AI Agent Cheats Without Being Told: Inside the Meta-Agent Challenge

  Meta-agents operate over 12–24 hour development cycles with constrained API budgets, requiring sustained autonomous planning.

• The Reasoning Cliff: Why Thinking Longer Makes Models Worse at Exact Step-by-Step Tasks

  The paper specifically studies performance degradation as the number of required deterministic steps grows into the tens and beyond.

• The Trojan Is Your Agent's Memory: Why Single-Step Defenses Miss Persistent Attacks

  The attack exploits multi-step, cross-session task execution where early innocent steps enable later harmful ones.

• How Treating an AI Agent's Execution Like Git Recovers a Coordination Penalty

  The paper explicitly targets long-lived, stateful agents whose multi-step executions require runtime-level control and credit assignment across many steps.

• Seven Wins to Zero: How Organizing AI Agents Like a Lab Changes the Search

  The paper specifically targets failure modes that emerge when single agents run long, open-ended experiment budgets.

• When Search Agents Don't Really Search: The Memory Shortcut Hiding in Browsing Benchmarks

  Multi-step deep research browsing tasks are the primary use case studied, requiring chained retrieval and reasoning.

• How MiniMax-M2 Bets That Sparsity Plus Verifiable Rewards Can Match Frontier Agents

  The entire paper is calibrated against multi-hour agentic workloads with hundreds of tool calls and 192K-token contexts.

• Terminal Agents Get Free Supervision From The Tokens We've Been Throwing Away

  Agents operate for up to 16 turns per rollout, requiring multi-step planning in a live terminal environment.

• Training the Translator: How a Small Communication Model Lets Agent Teams Outperform Themselves

  AgentFugue is explicitly designed for hard, multi-step search tasks like BrowseComp that require hundreds of reasoning steps.

• Same Model, Organized Differently: How an Agent Architecture Beat Frontier Systems at Research Math

  Research-level proof generation requires sustained multi-step reasoning over hours and hundreds of thousands of tokens.

• A Robot Made Graphene Without Help, And Caught Itself Hallucinating

  The transistor fabrication demo spans thirty discrete steps and eighteen decision points over ninety minutes, executed end-to-end without human intervention.

• The OS Trick That Makes Tree Search Practical for Coding Agents

  Enabling backtracking search over many steps is essential for long-horizon coding tasks with high branching complexity.

• When the AI Optimizer Edits the Grade Book: Why Harnessing Evolution Needs a Wall

  The paper addresses how to sustain useful progress across 100+ iteration budgets where fixed procedures and plain agents plateau early.

• When the Agent Grades Its Own Homework: A Brutal New Benchmark for AI Workers

  The benchmark's hardest split tests 200+ tasks requiring ~400 GUI steps, measuring agent failure on extended professional workflows.

• Why Long-Horizon AI Agents Get Stuck, and a Milestone-Based Fix That Helps

  The paper's central framing is that current LLMs fail on long-horizon tasks not due to lack of intelligence but lack of planning architecture.

• How to Pick the Best of Sixteen Coding Agent Rollouts

  The paper focuses on long-horizon agentic coding tasks involving 40+ step interactive sessions.

• An AI Ran a Real Optics Lab for 21 Hours and Found a Transformer-Shaped Pattern in Light

  The discovery study runs for 21.5 hours with ~3000 LLM calls and ~1200 lab tool calls, far exceeding typical agentic demos.