Based on Anthropic’s concept of long-running agents, developers have open-sourced the **Agent-Run-Kit** framework. Through task decomposition, context compression, and Git log management, it enables AI to continuously advance complex projects across multiple sessions, solving issues of long-task interruption and performance degradation.

Agent-Run-Kit: Let AI Agents Take Shifts Like Engineers

A developer saw a video showing someone letting an AI automatically develop for several hours, making dozens of commits and completing an entire project. Inspired, they spent two weeks building an open-source framework called Agent-Run-Kit, based on Anthropic’s long-running agent design. The core problem it tackles is: how can an AI maintain coherence across long tasks that span multiple context windows—without losing context or degrading in performance midway?

The Real Pain Points of Long-Running Agents

Anyone who’s used AI-assisted development has run into these issues: every new conversation requires re-feeding the model with context, or you spend ages explaining messy requirements—only for the model to output disappointing results. More disastrously, when it comes to long-running tasks, models often “downgrade.” They either try to “do everything in one shot,” exhausting the context mid-way and leaving many incomplete, undocumented features; or they mark tasks as completed without sufficient testing, forcing later agents to guess and waste time fixing fundamental bugs.

Anthropic’s long-running agent framework, released in March, provided a solution: an initialization agent handles environment setup, while a coding agent iteratively advances each session and leaves clear artifacts for the next one. The key insight is that by using progress files and Git history, the agent can quickly understand the current state when opening a new session—an approach borrowed from efficient software engineering practices.

Agent-Run-Kit is an engineering implementation of that idea.

Three Skills Power the Whole System

The architecture of Agent-Run-Kit is simple—just three core skills doing all the work:

Task_init is responsible for breaking requirements into n subtasks. This isn’t just a simple task list—it demands that the agent produce a detailed functional specification. For instance, in a “clone claude.ai” example, the list included over 200 items (at a level like “user can start a new conversation, input a query, press enter, and see a response”), all initially marked as “failed” to provide a clear blueprint for later development.

Auto_dev handles development. When you run $Auto_dev complete 3 tasks, the agent reads the task list, delegates work to sub-agents, and waits for their feedback. Crucially, it reads Git logs and progress files at session start to understand recent progress, and then commits to Git and updates progress at the end. This ensures that every session immediately spots and fixes existing bugs, instead of building new features on a broken base.

Context_archive compresses the context needed by agents. By reading work logs, the agent gathers recent project updates, and when the logs get too large, this skill compresses them—solving the limited context window issue and theoretically enabling indefinite operation.

Flow diagram of the three core skills of Agent-Run-Kit

Engineering Details: The Devil’s in the JSON (and Git)

The stability of this system comes from several key engineering designs.

First, manage task lists with JSON, not Markdown. Experiments show JSON structures are more resistant to unwanted model edits. The system requires the coding agent to modify only the passes field in the JSON file, strictly forbidding deletion or alteration of test items. This drastically reduces the chances of the AI “taking matters into its own hands.”

Second, enforce Git commits and progress logging. Best practice is for the agent to commit to Git (with descriptive messages) and write a summary in the progress file. This lets the agent revert errors via Git and restore usable states. The initialization agent creates the first Git repo and progress record; every subsequent coding agent must read these at the start, and commit and update them at the end.

Third, mandate end-to-end testing. By default, Claude might do unit tests or curl requests but neglect full end-to-end validation. When explicitly prompted to use browser automation tools for real user interactions, Claude performs very well in end-to-end verification. The system requires the initialization agent to create an init.sh script that launches the server and runs basic tests before development begins, ensuring each agent verifies core flows before developing on possibly broken foundations.

Practical Usage Flow

Setup is simple:

Create the required files (provided in the Agent-Run-Kit repository)
Ask the AI to produce a detailed project implementation plan, ideally divided by stages
Use $Task_init to plan subtasks for each stage, for example: $Task_init based on xxx, plan subtasks for stage one
Use $Auto_dev to start working, for example: $Auto_dev complete 3 tasks

That’s it—the agent begins working, with good stability. In the Linux.do community, the developer shared that after two weeks of testing and refinement, the system still has rough edges but runs reliably.

Why This Method Works

Agent-Run-Kit’s design philosophy can be summarized in this table:

| Failure Mode | Initialization Agent Response | Coding Agent Response | |---------------|-------------------------------|------------------------| | Tries to complete everything at once | Build a JSON list with end-to-end functional specifications | Read the list at session start, pick one feature to work on | | Prematurely declares project finished | Mark all features as “failed” initially | Modify only the passes field; never delete test items | | Environment bugs or unclear progress records | Create initial Git repo and progress records | Read progress files and Git logs, run base tests at start; commit and update progress at end | | Wastes time figuring out how to launch app | Write an init.sh script to start the dev server | Read and execute init.sh at session start | | Marks completion without proper testing | Require browser automation for E2E testing | Start the server and use Puppeteer to verify core flows |

The core idea is encoding human engineering habits into the system. Good engineers write detailed task lists, commit often, write tests, and keep work logs—Agent-Run-Kit forces the agent to do the same.

Limitations and Future Directions

Challenges remain, such as vision limitations and automation tool constraints—Claude cannot handle native browser dialogs via Puppeteer, making related features error-prone. Moreover, this demo mainly targets web development; future work could extend it to scientific research, financial modeling, and other long-horizon domains.

Anthropic’s shared framework was the product of multiple teams, particularly the Reinforcement Learning for Code and Claude Code groups. Agent-Run-Kit, as a community-level engineering implementation, proves the concept’s viability.

On a broader level, the long-running agent framework marks an important direction in AI agent development: it’s not about making models “smarter,” but about helping them stay coherent across multiple sessions. Achieving this requires more than better models—it needs thoughtful engineering: external memory, task breakdown, progress tracking, and test verification—all long-standing best practices from human engineers.

Agent-Run-Kit is still in its early stage. The developer openly acknowledges “many imperfections,” but it provides a runnable starting point for others to build long-running AI systems inspired by Anthropic’s approach. For developers who want AI to handle complex, time-consuming tasks, this is a promising direction.

If you’re also tinkering with AI agents, consider checking this system out. After all, teaching AI to take over shifts like engineers might just be more reliable than expecting it to finish everything at once.