Claude Sonnet 4.5 and the agent that runs for thirty hours

Anthropic released Claude Sonnet 4.5 with claims centered on sustained autonomous operation — reportedly maintaining focus on complex multi-step tasks for over thirty hours.

Alongside it: checkpoints in Claude Code, a VS Code extension, and context editing plus a memory tool in the API.

the long-horizon claim#

Thirty hours is a marketing number and the underlying capability is real and worth understanding.

The limiting factor on long agent runs has never been the context window. It is goal drift. As a session accumulates tool results, file contents, error messages, and the model's own prior reasoning, attention to the original objective degrades. The model starts optimizing for local signals — making this specific test pass — rather than the actual task.

The failure is insidious because each individual step looks reasonable. You come back after two hours to find the agent has been productively working on something adjacent to what you asked.

Improvements here come from three places: better training on long trajectories, architectural support for externalized memory, and mechanisms for periodically re-grounding on the original goal. This release touches all three.

the tooling#

Checkpoints in Claude Code. Save state, let the agent work, roll back if it goes wrong. This is the feature that makes long autonomous runs practically usable — the failure mode of a two-hour agent run is that you have to throw away two hours, and checkpointing converts that into "roll back twenty minutes."

Every delegated agent product needs this. It is the git stash of agent workflows.

Context editing in the API — programmatically removing content from the conversation. Sounds mundane, matters a lot. A tool result containing 40,000 tokens of build output is useful for one turn and is pure noise for the next fifty. Being able to drop it keeps the context focused and the cost down.

Memory tool — the model writes notes to a file and reads them back. An externalized working memory that survives compaction. This is the right pattern and it mirrors how people actually work on long tasks: you do not hold everything in your head, you write it down.

the pattern to steal#

Whatever model you use, this architecture is the one that works for long tasks:

1. A durable task description in a file, not in the conversation.
2. A working notes file the agent updates as it goes.
3. Aggressive pruning of tool output from the context once it has been acted on.
4. Checkpoints at natural boundaries so failure costs minutes, not hours.
5. Periodic re-grounding — literally re-reading the task description and asking whether current work serves it.

You can implement all of this yourself with any model and a bit of orchestration. The vendors shipping it as a feature is a convenience, not a requirement.

the caution#

A model that can work autonomously for thirty hours can also do thirty hours of damage.

The controls that matter scale with autonomy: run in a container, restrict credentials to what the task requires, require approval for anything irreversible, and review the diff.

Higher autonomy makes review harder and more important simultaneously. That tension does not resolve — it is the central design problem of the entire category, and nobody has a good answer beyond "keep a human in the loop and make the loop cheap."