Orchestrating automated development at scale through intelligent wave-based task execution, quality gates, and deterministic progress management.
The Roadmap Executor embodies a simple yet powerful philosophy: deterministic scripts should own decision-making, while agents serve as dispatchers. This design principle ensures that execution remains predictable, repeatable, and free from the unpredictability that often plagues AI-driven systems.
What once required weeks of careful coordination, daily standups, and constant status updates now happens systematically and predictably—transforming abstract roadmaps into concrete code with architectural consistency and quality built into the process.
Transforming static roadmaps into executable code with minimal human intervention through intelligent orchestration.
Rigorous 12-gate acceptance system ensuring only mature, well-considered roadmaps reach execution.
Cascade for continuous sessions, Interval for scheduled progress—adapting to project rhythms and scales.
Wave-based parallel task execution with file-affinity serialization preventing conflicts.
Every task includes test-driven development requirements with independent verification protocols.
Built-in overlap protection, self-deactivation on completion, and sophisticated error recovery.
Roadmaps pass through 12 acceptance gates—framework alignment, atomic tasks, resolved questions, testing strategy, concept alignment—ensuring production readiness before execution begins.
The roadmap-manifest.py script builds a directed acyclic graph from task dependencies, enabling intelligent wave dispatch and conflict prevention through file-affinity serialization.
Ready tasks execute in parallel waves of up to 9 concurrent agents, with each task receiving self-contained briefs including TDD instructions derived from the **Check** field.
The orchestrator never trusts subagent summaries—every task's acceptance criteria is independently verified through shell commands, Python assertions, and file existence checks.
Progress is atomically recorded via batch-complete commands, with state.json serving as the single source of truth while markdown remains frozen after promotion.
The Roadmap Executor's technical architecture prioritizes determinism, scalability, and quality assurance through a sophisticated combination of graph theory, state management, and verification protocols.
At its core, the system uses a directed acyclic graph where tasks are nodes and dependencies are edges, enabling intelligent parallel execution while maintaining strict ordering constraints where required.
Core infrastructure of graph-status, advance, and batch-complete commands managing execution flow and state persistence.
Automatic prevention of same-file conflicts between parallel tasks, ensuring data integrity during concurrent execution.
Standardized execution loop with deterministic decision-making by scripts, while agents serve as dispatchers only.
Markdown files are hashed and locked at promotion, with continuous monitoring preventing specification drift during execution.
File-based progress tracking with E{N}-Reports.md files and Discord notifications only for critical failures/blockers.
Overlap protection, automatic deactivation on completion, and structured halt/recovery mechanisms preventing system chaos.
The Roadmap Executor has fundamentally changed how large-scale development occurs. What once required weeks of careful coordination now happens systematically and predictably.
# Core graph commands
roadmap-manifest.py graph-status <roadmap_dir>
roadmap-manifest.py advance <roadmap_dir>
roadmap-manifest.py batch-complete <roadmap_dir> \
--nodes E1.1,E1.2,E2.1 \
--results '{"E1.1":"completed","E1.2":"completed"}'
# Build execution graph
roadmap-manifest.py build-graph <roadmap_dir>
# Wave execution pattern
while graph_status() != "COMPLETE":
ready_nodes = get_ready_nodes()
results = dispatch_wave(ready_nodes)
batch_complete(results)
advance_cursor()The Roadmap Executor represents more than just a tool—it's a new paradigm for software development. By combining deterministic scripting with adaptive AI agents, it creates systems that can handle the complexity of modern software development while maintaining the quality and consistency that manual processes often struggle to achieve.