Long-Horizon Tasks
Long-horizon tasks are goals that take an agent many dependent steps, much elapsed time or both to finish: migrating a codebase, running a multi-day research investigation, booking and rebooking an entire trip, operating a business process. The "horizon" is how far ahead the agent must keep acting coherently without a person correcting it. A model may answer a one-shot question flawlessly yet fall apart on a task that needs hundreds of actions, because the difficulty grows not just with the amount of work but with the way earlier mistakes, forgotten context and shifting circumstances accumulate along the chain.
The central mechanism is error compounding. If each step succeeds independently with probability p, a chain of n steps succeeds with probability p^n, so a respectable 98 percent per-step reliability gives roughly a 13 percent chance of completing a hundred-step task cleanly, and 95 percent per step gives well under one percent. Real tasks are not perfectly independent — many steps can be retried or silently self-corrected — so this arithmetic is a worst-case intuition rather than a prediction, but it explains why a small improvement in per-step accuracy can produce a dramatic improvement in the length of task an agent can finish. It also explains why error detection and recovery matter as much as raw skill: an agent that notices and repairs a slip breaks the multiplication.
Failures over long runs are not only wrong actions but also drift. The context window fills with logs and abandoned attempts, so early instructions and constraints get diluted or dropped; the agent may repeat a failing action in a loop, pursue a subgoal after it has stopped serving the real goal, declare success without verifying it, or change the task to something easier. Mitigations include summarizing and compacting history, keeping an explicit plan or progress file the agent re-reads, using external memory, splitting the work among sub-agents with clean contexts and giving each stage an objective check such as a test suite or a diff against expectations. Benchmarks with long, stateful tasks, for example WebArena-style environments or multi-hour software tasks, are designed to surface exactly these breakdowns.
METR, a nonprofit that evaluates frontier models, popularized a way to quantify the trend in 2025. Its time-horizon work measured how long a task is, in the time a skilled human would need, that an AI system can complete at a given success rate, such as one half, and reported that this length had been growing roughly exponentially over recent years across successive model generations. The result is best stated generally: horizons rose from seconds-scale tasks to tasks measured in tens of minutes or more, with reliability dropping sharply for longer or messier tasks, and the extrapolation depends on how the task suite was built and which rate is chosen. It is a useful yardstick for comparing models, not a guarantee about any particular real-world workload.
Checkpoints are the practical engineering answer to long horizons. A checkpoint is a saved, verifiable intermediate state — a committed branch, a database snapshot, a validated file, a short written status — that lets a run resume after a crash, roll back after a bad turn or hand control to a human at a defined point. Good designs place them before irreversible actions, make each stage idempotent where possible so a repeated step does no harm, bound the budget of steps, time and money, and keep a log that explains what the agent did and why. Human check-ins at milestones turn a single fragile hundred-step bet into several short, reviewable segments, which is also how people already supervise long projects.
A frequent misconception is that a larger context window or a smarter model alone solves the problem. Longer context helps memory, but it does not make an agent verify its work, stay on goal or detect when the world changed under it, and the cost and latency of replaying a long history grow with each step. Another pitfall is evaluating only on success rate while ignoring the cost of the failures: a run that quietly goes wrong at step sixty and continues for two hundred more steps can do more damage than one that stops early. Reliability on long horizons is thus partly a system property made of verification, recovery, scoping and oversight rather than just of the base model.
Read long-horizon tasks as the regime where reliability multiplies rather than adds: every extra step is another chance to fail, so the length of task an agent can finish grows with its per-step accuracy, its ability to notice and recover from its own errors, and the checkpoints and human milestones that turn one long gamble into a series of short, inspectable ones.