Four models work in shifts; what really lets the Agent remember yesterday is a txt file
NO1ennn broke down a long-running Agent harness: Fable as advisor, Sonnet writes features, Opus tests in the browser, Haiku scans files. More critically, the git commit and progress note before the end of each session are what the next shift uses to pick up where it left off.
NO1ennn posted a breakdown of a long-running Agent harness on X, along with a demo video. The core is the workflow: getting Claude to continue working across sessions.
The problem is simple. Every new Agent session starts from zero; the context window cannot hold the entire project, and compression does not guarantee the next shift will understand it. Anthropic's engineering article explains it in more detail: when a frontier model runs in a loop in the Agent SDK and is given only a single instruction like 'build a clone of claude.ai,' it tries to finish everything at once, runs out of context midway, and leaves behind half-finished features and undocumented code. The next session can only guess and first spends time repairing the basics. Another failure is even more common: the newcomer sees that progress has already been made and simply declares the work complete.
Their solution has two parts. The first session uses an initializer agent to set up the environment: write init.sh, write claude-progress.txt, create the initial git commit, and then break the requirements into feature_list.json. Each feature comes with test steps and is initially marked as failing. Subsequent sessions use a coding agent that first runs pwd, reads progress, reads git log, runs init.sh and basic end-to-end tests, confirms the current state, then picks the highest-priority unfinished feature and does only one. Before finishing, it must commit to git and clearly write down progress. Testing should use browser automation, clicking like a real person, not just unit tests. The gif in the official article shows Claude using Puppeteer to check the claude.ai clone.

The main post breaks this workflow down into model roles: Fable 5.2 acts as advisor, Sonnet 5.5 writes one feature at a time, Opus 5.5 tests in the browser, Haiku 5.5 handles file-level chores, and then git commit plus progress note let the next session continue where the previous one stopped. The official links in the post include Anthropic's long-running agents article and the Claude Code /advisor documentation. The advisor tool is experimental and lets the main model consult a stronger model at key decision points. The official documentation states that the main model and advisor model must form a valid pairing; Fable 5.2 requires Claude Code v2.1.321 or newer, and advisor depends on the Anthropic API or specific cloud platforms and is not available on platforms such as Bedrock.
Some commenters asked whether the next session should read the progress note or the git log. According to the official workflow, it reads both. The progress file tells the newcomer 'where the previous work got to, what problems were encountered, and what the next step is'; the git log and commit records provide a verifiable code state. Another commenter said the progress note matters more than the four models; skip it and every session starts from zero. Someone else added that the progress file should also clearly state 'what not to touch.' In long-running tasks, token costs are visible. If a newcomer mistakenly changes a piece of code that should not be touched, the cost is even higher.
There is something easy to overlook here. The model layering is impressive—Fable makes judgments, Sonnet types, Opus does acceptance testing, Haiku handles chores—it sounds like giving the Agent a duty roster. But what really lets the next shift pick up is the unglamorous stuff on disk: a feature list, a progress log, an init.sh that can actually run, and a series of commit records. Models forget; files do not.
If you want to follow along, the minimal version is not complicated. In the first session, split the features into a testable JSON list, and set up the startup script and initial commit. After that, each session first reads the progress and git log, runs the basic tests, and advances only one feature. Commit when done, and write discovered issues and next steps into the progress file. Do not run only unit tests; if a browser can be used, walk through the user path in the browser. When using /advisor, first confirm the model pairing and version; do not configure an advisor weaker than the main model. Finally, the progress file will become stale; regularly delete outdated 'never do' rules, or the Agent will become increasingly timid.
Reference links:
NO1ennn's post
Anthropic: Effective harnesses for long-running agents
Claude Code advisor documentation
发布时间: 2026-11-17 20:34