openclaw - 💡(How to fix) Fix Feature request: Long-spec autonomous build mode for very large software projects

Summary

I would like OpenCLAW to support a mode for very large software-development tasks where a user can provide extremely large specifications, for example around 10,000 pages of product requirements, technical constraints, business rules, UI descriptions, architecture notes, and test expectations, then let OpenCLAW work continuously toward building the complete software system.

The goal is not just a larger single prompt window. The goal is a durable autonomous build workflow that can run 24/7 over long periods of time while preserving context, decisions, progress, tests, and implementation state.

Use case

A user has a complete software specification that is too large to fit into a normal prompt or to manage manually through many short chat sessions. They want to upload or connect the full corpus of requirements, then ask OpenCLAW to plan, implement, test, fix, and iterate until the application is complete.

Example scenario:

• Input: approximately 10,000 pages of specifications and related project context
• Task: build the complete software described by those specifications
• Runtime: potentially days, weeks, or months
• Execution: continuous 24/7 agentic work with checkpoints, logs, resumability, and self-validation
• Output: a working software project with source code, tests, documentation, deployment instructions, and traceability back to the requirements

Requested capabilities

1. Large specification ingestion

Support uploading, importing, or connecting a very large requirement corpus, such as PDFs, Markdown files, Word documents, diagrams, OpenAPI specs, database schemas, UI mockups, and existing source code.

The system should not simply paste everything into one model context. It should index, chunk, summarize, deduplicate, classify, and retrieve the right information when needed.

2. Persistent long-term project memory

OpenCLAW should maintain durable memory across long runs, including:

• requirements database
• architectural decisions
• implementation plan
• completed tasks
• pending tasks
• known bugs
• test results
• generated files
• unresolved ambiguities
• traceability between code and requirements

This memory should survive restarts and allow the task to resume after interruption.

3. Continuous 24/7 autonomous execution

Add an execution mode where OpenCLAW can continue working without requiring a new chat message for every step. It should be able to run for very long periods, such as days or weeks, while regularly committing progress, running tests, updating status, and deciding the next task.

Important controls would include:

• pause / resume
• stop conditions
• compute and cost limits
• maximum runtime
• safety approvals for risky operations
• periodic status reports
• checkpointing
• rollback

4. Hierarchical planning for complete software builds

For a 10,000-page specification, OpenCLAW would need to break the project into milestones, modules, epics, tasks, subtasks, tests, and validation criteria.

Ideally, it should create and maintain a living project plan, then work through it systematically rather than attempting to solve everything in one model call.

5. Requirement-to-code traceability

Every implemented feature should be linked back to the relevant requirement sections. This would make it possible to audit what was implemented, what is missing, and what tests verify each requirement.

Suggested outputs:

• requirement coverage report
• implemented / partially implemented / not implemented status
• links between requirements, commits, source files, and tests
• contradiction and ambiguity reports

6. Self-testing and validation loop

The agent should continuously run tests, static analysis, linting, type checks, integration tests, end-to-end tests, and possibly generated acceptance tests derived from the specification.

When something fails, it should diagnose, fix, and retest automatically.

7. Multi-agent or role-based workflow

This feature could use specialized roles such as:

• product analyst
• software architect
• backend engineer
• frontend engineer
• database engineer
• QA engineer
• security reviewer
• DevOps engineer
• documentation writer

Each role could use the shared project memory and requirement index.

Why this matters

Current AI coding tools are useful for small or medium tasks, but they struggle when the input context is extremely large and when the target is a complete production-grade application rather than a small patch.

A long-spec autonomous build mode would make OpenCLAW much more useful for real-world enterprise projects where the full context may be thousands of pages and implementation requires sustained work over time.

Possible implementation direction

This could be implemented as a dedicated project mode with:

• document ingestion pipeline
• vector search and/or graph-based retrieval
• requirement extraction and normalization
• persistent task graph
• durable execution engine
• checkpointed agent loops
• CI/test integration
• generated acceptance criteria
• requirement coverage tracking
• periodic human review gates

Expected behavior

A user should be able to say something like:

Here are 10,000 pages of specifications. Build the complete application described in them. Work continuously, create a plan, implement incrementally, run tests, keep track of requirement coverage, ask only when blocked by ambiguity, and continue until the software is complete or a configured stop condition is reached.

OpenCLAW should then create a long-running build plan, ingest and index the full context, execute the work continuously, preserve state, and provide progress reports until the project is completed or stopped.

Additional notes

I understand that this is a very ambitious feature and that “build an entire complex system from 10,000 pages in one run” may not be fully achievable with current LLM limitations. However, even partial support for durable long-running autonomous development with massive specification ingestion would be extremely valuable.