flow-next

Generates structured task plans before execution by analyzing user intent and decomposing complex workflows into atomic subtasks with dependency graphs. Uses a planning-first architecture where Claude or Codex models create explicit task hierarchies (with parent-child relationships, sequencing constraints, and resource requirements) that are then validated and executed by worker subagents. The planner outputs a machine-readable task DAG that prevents execution until the full workflow structure is validated.

Spawns and manages multiple specialized subagents (workers) that execute assigned tasks in parallel or sequence based on the task DAG. Each worker receives a scoped task context, execution constraints, and access to specific tools/APIs. The orchestrator handles worker lifecycle (creation, monitoring, cleanup), inter-worker communication via a message queue, and aggregates results back to the main workflow. Workers are stateless and can be horizontally scaled.

Captures detailed execution telemetry (task start/end times, worker IDs, API calls, token usage, errors) and logs it in structured format (JSON) for analysis. Provides real-time monitoring dashboard (optional) showing task progress, worker status, and resource usage. Logs are queryable and can be exported for external analysis. Supports custom metrics and event hooks.

Enables creation of reusable task templates and workflow macros that can be composed into larger workflows. Templates define parameterized task specifications (e.g., 'code-review' template with configurable rubric), and macros combine multiple templates into common patterns (e.g., 'review-and-refactor' macro). Composition is declarative and supports nesting. Templates are versioned and can be shared across projects.

Enables fully autonomous workflow execution where the system makes execution decisions without human approval gates. Ralph mode uses a confidence-scoring mechanism to determine when human review is necessary vs. when the system can proceed autonomously. The system maintains an audit trail of autonomous decisions and can roll back if issues are detected post-execution. Autonomy is configurable per task type (e.g., code generation requires review, file deletion requires approval).

Executes code review tasks across multiple LLM providers (Claude, Codex, etc.) in parallel and aggregates findings using a consensus mechanism. Each model reviews the same code independently, and the system identifies common issues (high-confidence findings) vs. divergent opinions (model-specific concerns). Results are ranked by consensus strength and presented with model attribution. Supports custom review rubrics and can weight models by historical accuracy.

Maintains workflow execution state and task progress without external databases or state stores. Uses in-memory task registry with optional file-based persistence (JSON/YAML snapshots). Task state includes status (pending/running/completed/failed), execution metadata (start time, duration, worker ID), and result artifacts. State is immutable and versioned — each state change creates a new snapshot. Supports local-first operation with optional cloud sync.

Provides native plugins for Claude Code and Factory Droid IDEs that embed workflow execution directly in the editor. Workflows are triggered via IDE commands or inline annotations, and results are displayed in editor panels or inline. The plugin maintains context awareness of the current file/project and passes relevant code context to the workflow engine. Supports VS Code-style command palette integration and keybinding customization.

Abstracts LLM provider differences behind a unified interface, allowing workflows to switch between Claude, Codex, and other providers without code changes. Handles provider-specific API differences (function calling schemas, token limits, rate limits) transparently. Supports model-specific optimizations (e.g., using Claude for reasoning, Codex for code generation) and automatic fallback if a provider is unavailable. Provider configuration is declarative (YAML/JSON).

Exposes workflow execution via command-line interface with structured argument parsing, environment variable support, and shell integration. Workflows can be invoked as `flow-next run <workflow-name> --arg1 value1 --arg2 value2`, with arguments validated against a schema. Supports piping input/output for shell composition and exit codes for CI/CD integration. Environment variables are automatically injected into workflow context.

Allows workflows to be defined declaratively in YAML or JSON with a strict schema that validates structure before execution. Definitions include task specifications, dependencies, worker assignments, and execution policies. Schema validation catches configuration errors early (missing required fields, invalid task references, circular dependencies). Supports schema versioning and migration for backward compatibility.

Automatically indexes the current codebase (file tree, imports, function signatures, dependencies) and makes this context available to workflow tasks. Indexing uses AST parsing or language-specific tools to extract semantic information (not just text search). Context is passed to LLM tasks as structured data, enabling model-aware code generation and refactoring. Supports incremental indexing for large codebases.