Long-Horizon Agent

What It Is

A long-horizon agent is an AI agent built to keep working on a single task across dozens or hundreds of steps, often over hours of elapsed time, without losing track of what it was doing or why. The short-horizon version of an agent is the one you watch finish a five-step task in three minutes. The long-horizon version is the one you assign a multi-stage refactor and check on after lunch. The term entered general AI vocabulary in 2025 as frontier labs began benchmarking their models not just on single-turn answers but on sustained sessions where the agent has to remember its own earlier decisions, recover from its own earlier mistakes, and keep moving toward an objective that no longer fits in the context window.

Cursor’s Composer 2.5 release in May 2026 positioned long-horizon behavior as the headline capability. The marketing language was “sustained work on long-running tasks,” which is the polite way of saying that prior agents could not be left alone for an hour without producing something that needed to be unwound. A long-horizon agent is the version where leaving it alone for an hour produces work you actually want to keep.

How It Actually Works

Three mechanisms do most of the lifting. The first is a larger working context window, which lets the agent hold the original task, the current state, and recent decisions in a single view rather than re-reading them each turn. The second is structured memory, where the agent writes its own progress notes to a scratchpad or repository and reads them back the way a human takes meeting notes. The third is checkpointing and sub-agent delegation, where the parent agent breaks a long task into stages, dispatches a fresh sub-agent for each stage, and then re-integrates the result without dragging the entire history forward.

The hard part is not any single mechanism. The hard part is that the failure modes compound. A short-horizon agent that gets confused in step three can be corrected by a human in step four. A long-horizon agent that gets confused in step three carries the confusion into steps four through forty, and the cleanup cost grows non-linearly. Modern long-horizon designs spend most of their engineering budget on detecting drift early and resetting rather than on raw capability per step.

The Cost and Tradeoff

Long-horizon agents are expensive to run because each step is paying full inference cost over a context that keeps growing. They are also expensive to evaluate because a single bad run can burn hours of compute and produce nothing useful. The market response has been to drive the per-token price down hard. Cursor’s Composer 2.5 launched at $0.50 per million input tokens and $2.50 per million output, which is roughly an order of magnitude below frontier-lab pricing for comparable work, on the bet that long-horizon sessions only become economically interesting when the per-step cost is small enough to absorb the failure tax. See agent-loop-cost for the deeper structure of that math.

How TWO Uses It

The operator question is not whether the long-horizon agent is technically capable of finishing a multi-hour task. It almost always is, on a good day. The operator question is whether the failure mode of the long-horizon agent is one you can live with on a bad day. Scott’s heuristic at The Wise Operator: if the task can be picked up by a human after the agent stops, with no irreversible side effects in the meantime, hand it to the long-horizon agent. If the task involves writing to production, hitting an external API with side effects, or chaining decisions where step thirty depends on a confident-but-wrong step three, keep a human in the loop and use the short-horizon version inside agentic coding sessions instead.

The deeper move is to design the work so that the agent can fail mid-stream and the project still moves forward. That means committing checkpoints to source control, scoping each delegated stage to a single review-sized diff, and refusing to give the agent privileges it does not need for the next twenty minutes of work. The long-horizon capability is real; the prudent disposition toward it is still skeptical.

A Concrete Operator Scenario

You have a 30-step refactor: pulling a legacy auth flow out of a monolith into a service, updating every callsite, regenerating tests, and deploying to a staging environment. The short-horizon agent could do step one. The long-horizon agent claims it can do all thirty in a single session. The operator decision: do you let it.

The disciplined answer is to give the agent the first ten steps with a hard stop at staging, review the diff, and only then release the next ten. The undisciplined answer is to give it the whole task and a credit card. The difference between those two operators a year from now is not raw productivity. It is whose codebase is still legible.