Millrace: An Autonomous Software Delivery Runtime for Long-Running AI Programming Tasks

Millrace is a local autonomous software delivery runtime designed specifically for long-running coding tasks. It addresses the shortcomings of mainstream AI programming tools in long-running tasks (such as lack of persistent state, recoverable execution, and governance handover) through file-driven governance, validated execution phases, and self-healing recovery mechanisms, providing reliable support for unattended end-to-end agent workflows.

Current mainstream interactive programming tools like GitHub Copilot and Cursor focus on short-term conversational interactions, but long-running tasks (such as cross-hour/day requirement analysis and architecture design) lack capabilities like queue discipline, persistent state, and recoverable execution, relying on unreliable implicit mechanisms like shell history and chat logs. Millrace's core insight: Long-running AI programming work requires a true runtime environment with lifecycle management, queue changes, and persistent state.

Millrace adopts a layered architecture: the underlying runtime engine manages lifecycle, state, etc.; the upper layer is divided into an execution plane (delivery work) and a research plane (requirement analysis), which share the engine but have independent states. The file-driven design (millrace.toml configuration + agents directory storing queues, logs, etc.) ensures the workspace is inspectable and backupable. Core mechanisms include: frozen plan (fixing the execution plan before running to avoid configuration drift), self-healing recovery (disk-persisted state allows recovery of unfinished tasks after crashes).

The research plane handles requirement analysis via the add-idea command, generates specifications and execution tasks, then hands them over to the execution plane, separating requirement review from code implementation. It supports OpenClaw-compatible external supervision: supervisors obtain status via supervisor report --json, and use CLI operations with signers (like pause/resume) to ensure action traceability, facilitating audit for multi-agent collaboration.

The TUI is based on the Textual framework, providing multi-panel operations (overview, queue, logs, etc.), automatic health checks before startup, and support for operator/debug modes. Installation via PyPI: python3 -m pip install millrace-ai; create workspace millrace init; check readiness doctor; add task add-task; start execution start --once/--daemon; start TUI python3 -m millrace_engine.tui.

Design principles: Explicit boundaries (independent surfaces for lifecycle, state, etc.), recoverability first, honest failure (exposing blockages/partial progress). Application scenarios: Long-running AI programming tasks like large-scale code migration and multi-module refactoring. The project is MIT open-source with clear code and complete documentation, providing a reference architecture and infrastructure for production-grade AI programming systems.