People keep saying one model or another is really good at long-running tasks, and I still don’t fully get what they mean. If you are running an agent for hours and hours, a single context window explodes. So this has to be a harness, right?

Where the Multi-Hour Runs Actually Come From

Yes. For hours and hours it is always a harness. There is no bare agent grinding away for hours inside one context window. Even a million-token window fills, and well before it fills the material sitting in the middle stops reliably steering anything. Every real example of multi-hour autonomy I can find is the harness doing context management: the loop, the work queue, and the restart logic sitting outside the model.

Ralph Wiggum, in its purest form, is a bash loop that pipes the same prompt file into a new context window over and over: while :; do cat PROMPT.md | claude-code ; done. Gas Town gives its agents explicit roles and puts the work queue on a hook, which it calls a durability primitive because work on the hook survives session restarts, context compaction, and handoffs. Cursor’s week-long browser run was hundreds of workers coordinated by planners, with a judge agent deciding at the end of each cycle whether to continue, and the next iteration starting fresh. The re-prompting and the persistent hooks exist precisely because the agent restarts and loses context.

The Cluster of Behaviors People Are Naming

So “good at long-running tasks” isn’t a claim about a bigger context window. It conflates a model property with a harness capability. When people say it, I think what they mean is a cluster of behaviors that let the harness run with less babysitting, and all of them are RL-trained agency and instruction following deep in context rather than context length.

  • It doesn’t give back control early. Cursor reports that the GPT-5.2 models are much better at extended autonomous work, and separately that Opus 4.5 “tends to stop earlier and take shortcuts when convenient, yielding back control quickly.” I read those as the same finding: a model that keeps stopping to ask whether it should continue forces the harness to nudge constantly.
  • It degrades gracefully as context fills, so the harness can compact less often, and compaction is where most of the quality loss happens.
  • It self-compacts well. When the harness has the model write its own state out before a wipe, say into a next-steps file, a model that produces a faithful one survives the handoff.
  • It recovers from its own errors instead of spiraling into a doom loop.

Two Camps

The bigger point is that this whole frame is a Camp 1 metric, and I mostly live in Camp 2. Camp 1 pushes the model to survive longer in one continuous run: thin harness, and the model carries the state. Even the fleet version of that instinct runs expensive, and Cursor is open about what it costs, having deployed trillions of tokens toward a single goal on a system it says isn’t perfectly efficient.

Camp 2, mine, makes each task stateless and short and externalizes state to disk and memory, so the harness is the durable brain and the model is interchangeable compute. In Camp 2, within-session longevity barely matters. “Doesn’t give back control after four hours” is irrelevant when no task runs four hours and every one starts from fresh context anyway. So the praise is measuring the wrong layer for the architecture I actually believe in.

Where Longevity Still Matters to Me

The one place it still counts for me is goal decomposition, the judgment-heavy orchestrator role that genuinely benefits from staying coherent over a long thin thread. I haven’t found a cheap way to wipe that judgment and restart it without losing the thread.

The ticket-to-PR layer underneath it doesn’t need any of that. In my setup those runs are short and stateless by design. So if there is a real reason to care whether a model is good at long-running work, I think it lives at the decomposition layer and not much below it.

Good Compared to What?

And honestly, “people keep saying it” is folklore until someone measures it the way Cursor measured GPT-5.2 against Opus. Good compared to what, on what task, with what harness? Even the Cursor result is one team’s harness on one browser project, which is far more evidence than most of these claims come with, and still not a general law.

Most “model X is good at long-running” claims take high agency and good instruction following deep in context, then mythologize them into “it can run for hours.” That last part is a harness capability, not something the model ever had on its own.