Anthropic releases another masterpiece on Agent engineering practice: Effective harnesses for long-running agents, highly recommended for everyone to read.
Previously, I introduced the Anthropic Agent article collection here:
<blockquote>
<ul>
<li>The second half of Agents! More important than Prompt is &#34;context engineering,&#34; Anthropic's first systematic elaboration.</li>
<li>Everything can be an Agent! Anthropic's official &#34;three-step cycle method&#34; teaches you how to create the strongest intelligent agent step by step.</li>
<li>Anthropic strikes again! A folder that trains Claude into a truly functional Agent.</li>
<li>Another masterpiece on Agent development from Anthropic, a new paradigm reduces Token consumption by 98.7%.</li>
</ul>
</blockquote>
As the capabilities of AI Agents improve, developers are beginning to require them to undertake complex tasks that span hours or even days. However, how to maintain consistent progress across multiple context windows remains an unsolved challenge.
The core challenge faced by long-running Agents is that they must work in &#34;sessions,&#34; and each new session starts like a new engineer with no past memory. Due to the limited context window and the complexity of projects that cannot be completed in a single window, Agents need a mechanism to bridge the gap between coding sessions.
The Anthropic engineering team developed a two-part solution for the Claude Agent SDK by observing how human engineers work: Initializer Agent and Coding Agent.
<h2>Core Challenge: Context Compression is Not Enough</h2>
The Claude Agent SDK is a general-purpose Agent framework with context management capabilities (such as compression), which theoretically should allow Agents to work indefinitely.
However, in practical tests (for example, asking the latest Opus 4.5 to build a clone of claude.ai), relying solely on context compression is insufficient. Claude primarily exhibits two failure modes:
<ol>
<li>
Trying to complete all work at once: Agents tend to do too much in a single session, leading to context exhaustion midway, leaving only half-completed functions and lacking documentation. The next session's Agent must guess what happened previously, wasting a lot of time fixing foundational applications.
</li>
<li>
Announcing completion too early: In the later stages of a project, new Agent instances see that some functions are already present and mistakenly believe the entire work is complete.
</li>
</ol>
<h2>Solution: Dual Agent Architecture</h2>
Anthropic breaks down the problem and proposes a dual solution:
Initialization Agent: The first session uses dedicated prompts to set up the environment. This includes generating the <code>init.sh</code> script, a <code>claude-progress.txt</code> file to record progress, and an initial Git commit to show file additions.
Coding Agent: Each subsequent session is dedicated to achieving incremental progress and leaving structured updates.
The key to this solution is enabling the Agent to quickly understand the work status when opening a new window—this is primarily achieved through the <code>claude-progress.txt</code> file and Git history.
<h2>Three Pillars of Environment Management</h2>
To support this workflow, the environment setup includes the following key components:
1. Feature List
To prevent the Agent from rushing or ending too early, the Initialization Agent is required to write a detailed document containing all functional requirements. In the case of the claude.ai clone, this includes over 200 functional points.
These features are initially marked as &#34;failing,&#34; providing a clear overview of the work for subsequent Agents.
Example JSON File:
<pre><code>{ &#34;category&#34;: &#34;functional&#34;, &#34;description&#34;: &#34;New chat button creates a fresh conversation&#34;, &#34;steps&#34;: [ &#34;Navigate to main interface&#34;, &#34;Click the 'New Chat' button&#34;, &#34;Verify a new conversation is created&#34;, &#34;Check that chat area shows welcome state&#34;, &#34;Verify conversation appears in sidebar&#34; ], &#34;passes&#34;: false }
</code></pre>
Experiments have shown that using JSON format is superior to Markdown, as the model is less likely to mistakenly alter or overwrite JSON files. Additionally, the prompts must contain strict instructions prohibiting the deletion or editing of tests, allowing only changes to the <code>passes</code> field status.
2. Incremental Progress
With the initial scaffolding in place, the Coding Agent is required to work on one feature at a time
To maintain a clean environment, the Agent needs to:
Submit code via Git after each code change, along with descriptive information;
Write a summary in the progress file.
This allows the model to utilize Git to roll back erroneous code and restore to a working state, avoiding situations where subsequent Agents have to guess what their predecessors did.
3. End-to-End Testing
Another major failure mode for Claude is marking features as complete without proper testing. It often only performs unit tests or simple curl commands, neglecting end-to-end validation.
The solution is to explicitly prompt Claude to use browser automation tools (such as Puppeteer MCP server) to test like a human user. By allowing Claude to see screenshots, it can identify and fix non-obvious bugs in the code.
<h2>Getting Up to Speed</h2>
Based on the above architecture, each coding Agent is prompted to execute a series of standard steps at the beginning of a session:
<blockquote>
<ol>
<li>
Run <code>pwd</code> to check the current working directory.
</li>
<li>
Read the Git log and progress file to understand what has recently been completed.
</li>
<li>
Read the feature list file and select the highest priority unfinished feature.
</li>
<li>
Run <code>init.sh</code> to start the development server.
</li>
<li>
Before implementing new features, run basic end-to-end tests to ensure the application is not in a broken state.
</li>
</ol>
</blockquote>
Typical Session Flow Example:
<blockquote>
[Assistant] Let me first understand the current status of the project.
[Tool Use] <code>&lt;bash - pwd&gt;</code>
[Tool Use] <code>&lt;read - claude-progress.txt&gt;</code>
[Tool Use] <code>&lt;read - feature_list.json&gt;</code>
[Assistant] Checking the Git log...
[Tool Use] <code>&lt;bash - git log --oneline -20&gt;</code>
[Assistant] Checking for startup scripts and restarting the server...
[Assistant] Now verifying if basic functionalities are working...
[Assistant] Verification passed. Now I will check tests.json to decide what to do next.
</blockquote>
<h2>Common Failure Modes and Fixes Summary</h2>
<img src="https://imageproxy.pbkrs.com/https://wpimg-wscn.awtmt.com/b470e2a2-bb44-4ba7-888e-fa26ebb56525.png?x-oss-process=image/auto-orient,1/interlace,1/resize,w_1440,h_1440/quality,q_95/format,jpg" alt="" original-src="https://imageproxy.pbkrs.com/https://wpimg-wscn.awtmt.com/b470e2a2-bb44-4ba7-888e-fa26ebb56525.png"/>
<h2>Conclusion</h2>
This research demonstrates a viable solution for the long-range Agent framework, but there are still unresolved issues:
Single Agent vs. Multi-Agent: It is currently unclear whether a general-purpose coding Agent performs best or if a multi-Agent architecture (such as dedicated testing Agents, QA Agents, and code cleanup Agents) is superior.
Domain Generalization: This demonstration focuses on full-stack web development. Future directions involve extending these experiences to other long-range task areas such as scientific research or financial modeling.
Risk Warning and Disclaimer
The market carries risks, and investment requires caution. This article does not constitute personal investment advice and does not take into account the specific investment goals, financial situation, or needs of individual users. Users should consider whether any opinions, views, or conclusions in this article align with their specific circumstances. Investment based on this is at their own risk

GOOG

Anthropic released a new article discussing the engineering practices of long-running agents and proposed solutions to the challenges of long-term tasks. The article introduces how to develop two parts of solutions for the Claude Agent SDK—initializing agents and coding agents—by simulating the working methods of human engineers to address the challenges of context window limitations and complex tasks

- Anthropic has developed a dual-agent framework to enhance the performance of long-running AI agents, addressing challenges in maintaining context across sessions.  
- The framework includes an Initializer Agent to set up the environment and a Coding Agent to make incremental progress, ensuring structured updates and effective communication of project status.  
- This approach aims to improve the efficiency of AI agents in complex tasks, although further exploration is needed to determine the optimal use of single versus multiple agents in various fields.

Anthropic releases Agent paper again: Thinking like human engineers to solve the "long-range task" problem