@aiDotEngineer: Most agents die after a few seconds. @AnthropicAI's workshop shows how to build agents that run for hours. full 75-min …

Most agents die after a few seconds. @AnthropicAI’s workshop shows how to build agents that run for hours. full 75-min session with Ash Prabaker & Andrew Wilson.

https://t.co/nHzXiMussk https://t.co/9O0fQNx5GH

TL;DR

Anthropic’s Applied AI team shared how to build agents that can run for 5–6 hours or even longer. The core challenges include context management, planning, and self-verification. Through iterative improvements to scaffolding tools (Claude Code/Agent SDK) alongside model upgrades, they achieved the breakthrough from “crashing in minutes” to “working continuously for days.”

Why is it hard for agents to run for a long time?

When agents are asked to perform complex coding tasks (e.g., “write a browser” or “clone Slack”), they often fail within seconds to minutes. The reasons can be grouped into three categories:

• Limited context: Each new session is like amnesia; memory components are needed. Long runs cause “context corruption” (coherence degradation). Models experience “context anxiety” near the end of the context window, rushing to finish tasks.
• Insufficient planning: Out of the box, models aren’t good at planning; they might try to do everything at once, only half-complete features, or leave unfinished work when context runs out.
• Difficulty with self-verification: Models have a tendency to “please” and misjudge their own outputs (e.g., think a button feature is implemented when the backend doesn’t exist).

The solution has two paths: one is improving the model itself (e.g., using stronger base models to extend runtime without tools), and the other is optimizing the “scaffolding” (tools around the model).

Historical Review: From “barely running 20 minutes” to “running for days”

Prehistoric Era (about a year ago)

• Sonnet 3.5 was the first model to show coding potential (can verify and iterate on what it builds).
• At the same time, launched Computer Use (click, screenshot, test code) and MCP specification (tool calls).

Claude Code Phase (February 2025)

• Released Sonnet 3.7, reaching top-tier performance on Swebench.
• Claude Code released as a research preview, with the goal of guiding model improvements through developer usage.
• Core idea: model and scaffolding tools co-evolve.

Collaborative Improvement of Tools and Models (Mid 2025)

• Opus 4 / Sonnet 4 (around May 2025): Models significantly improved at managing their own context and completing tasks, eliminating issues like reward hacking.
• Agent SDK (formerly Claude Code SDK) released, including the core agent loop: Claude decides next step, calls tools (can be from MCP server), delegates to sub-agents, and introduces claude.md, loaded skills, slash commands, etc. as context.
• Also introduced Ralph Loop technique (by Jeffrey Huntley): decomposes the prompt into a feature list, processes one task per fresh context window, iterates until done. Claude Code’s version runs within a single session and relies on compression rather than new contexts.

Mid to Late 2025: Stronger Models and More Scaffolding

• Sonnet 4.5 enhanced context awareness, can track token consumption and actively manage context.
• Claude Code 2.0 introduced checkpoints, allowing rollback to earlier session states.
• Haiku 4.5 and Opus 4.5 series significantly reduced costs, enabling many sub-agents. Opus 4.5 excels at planning (ideal as a planner agent), Sonnet 4.5 as the execution powerhouse.
• Skills use “progressive disclosure”: only the skill title is loaded; full content is loaded only when instantiated, avoiding early context consumption.
• Programmatic tool calls: run a series of tool calls at once by writing code, returning only the final result, reducing context usage.

First Blog Post on Long-Running Agents (around November 2025)

• Scaffolding tools decompose vague user instructions (e.g., “create Slack clone”) into persistent artifacts:
  • Feature list (featurelist.json, models are less likely to overwrite JSON)
  • Progress file
  • Git repository initialization
  • Startup script
  • Feature completion flag (whether all tests pass)
• Loop flow:
  1. Fresh context window → get current state (working directory, progress file)
  2. Smoke test / startup script (avoid re-exploring the server each time)
  3. Pick a feature that hasn’t passed tests
  4. Implement only that feature and run actual tests (like a human using Puppeteer)
  5. If passed, commit to Git, update status to “pass”
  6. Continue loop until all features are done

Latest Progress: Opus 4.6 / Sonnet 4.6 and Agent Teams

• Sonnet 4.6 offers Opus-level intelligence at Sonnet price, becoming the workhorse of Claude Code.
• Opus 4.6 is highly “agentic,” jumping from ~4 hours runtime on simple scaffolding to 12 hours.
• Agent Teams allow users to build custom agent teams; sub-agents can communicate directly without reporting to the main agent at every step. Also introduces server-side compression for further context optimization.

Key Takeaways

• Models and scaffolding tools must co-evolve. Each model release is accompanied by scaffolding updates.
• Value of Ralph Loop: predictable failure is better than unpredictable success; by partitioning context and iterating, complex tasks are completed.
• Persistent artifacts (like featurelist.json) are more reliable than markdown, reducing the risk of model overwriting files.
• Testing and verification loops are key to long-run stability, especially enabling models to self-judge outputs rather than pleasing the user.

Source: YouTube video: @aiDotEngineer: Most agents die after a few seconds. @AnthropicAI’s workshop shows how to build agents that run for hours. full 75-min … (https://www.youtube.com/watch?v=mR-WAvEPRwE)