subagents

Configure complexity scoring, models, and workflow options

Launch a multi-phase debugging workflow with parallel exploration, solution proposals, ranking, implementation, review, and documentation

Start a subagent workflow using Claude agents only (no Codex MCP)

Start a subagent workflow with Codex MCP defaults (use dispatch-claude for Claude-only)

Fast dispatch - streamlined 4-phase workflow with combined plan+implement+review (Claude-only, no Codex MCP)

Fast dispatch - streamlined 4-phase workflow with combined plan+implement+review (Codex MCP defaults)

Create a git worktree and start a subagent workflow (persists across Claude restarts)

Verify that the environment is ready for a subagent workflow. Run this before `/subagents:dispatch` or `/subagents:dispatch-claude`.

Resume a previously stopped or failed workflow from the last checkpoint.

Show current subagent workflow progress and status

Checkpoint and pause the current subagent workflow

Finalize work by committing changes, pushing to GitHub, optionally creating a PR, and cleaning up the worktree.

Analyzes existing codebase patterns and conventions, provides architecture blueprint with component designs and data flows.

Analyzes explore findings and determines implementation approach with trade-offs. Use proactively after codebase exploration to evaluate strategies before planning.

Reviews session for learnings and updates CLAUDE.md with concise context for future sessions.

Use proactively to review plans, implementation, tests, and final output using Claude reasoning (no Codex MCP)

Reviews code for bugs, logic errors, style violations, and adherence to project conventions.

Thin Codex MCP wrapper for code quality review — bugs, logic errors, style violations, project conventions.

Thin Codex MCP wrapper for comment review — accuracy, staleness, misleading documentation.

Thin MCP wrapper that dispatches task complexity scoring to Codex MCP for model assignment during implementation

Thin MCP wrapper that dispatches documentation updates to Codex MCP

Thin Codex MCP wrapper for error handling review — silent failures, swallowed errors, bad fallbacks.

Thin Codex MCP wrapper that dispatches explore result aggregation

Thin MCP wrapper that dispatches test/lint failure analysis to Codex MCP for root cause identification and fixes

Thin Codex MCP wrapper that dispatches plan result aggregation

Thin MCP wrapper that dispatches code review to Codex MCP during subagents workflow

Task executor for hard complexity tasks — thin codex-high MCP wrapper. Dispatches implementation to Codex and returns results.

Thin Codex MCP wrapper for test coverage review — coverage gaps, edge cases, test quality.

Thin MCP wrapper that dispatches test development to Codex MCP for coverage gap-filling

Thin MCP wrapper that dispatches lint/test execution and failure analysis to Codex MCP, captures results as structured JSON

Thin Codex MCP wrapper for type design review — encapsulation, invariants, type safety.

Thin Codex MCP wrapper for comprehensive code review — code quality, error handling, type design, test coverage, and comment accuracy in a single call.

Analyzes comment accuracy, completeness, and long-term maintainability. Flags stale or misleading comments.

Completes workflow with git operations - branch creation, commit, and optional PR. Use proactively when final review is approved.

Updates documentation after a debug fix is applied and reviewed.

Explores codebase to gather context around a bug or issue. Dispatched as parallel batch (3-5 agents) with focused exploration queries.

Implements the selected debug solution from aggregated proposals. Reads codebase, applies fix, writes tests.

Reviews debug fix implementation for correctness, completeness, and regression risk.

Deep architecture tracing — execution paths, layer mapping, dependency analysis. Complements breadth-first explorer agents.

Scores task complexity using Claude reasoning to determine model assignment for implementation. Use proactively when tasks need complexity-based model routing.

Updates documentation to reflect implemented changes. Use proactively after implementation to keep docs in sync.

Finds silent failures, swallowed errors, inappropriate fallbacks, and inadequate error handling.

Aggregates parallel explorer outputs into a single exploration report. Use after all explorer and deep-explorer agents have written their temp files.

Use proactively to explore codebase structure, find patterns, and gather context before planning - dispatched as parallel batch (1-10 agents)

Analyzes test/lint failures, identifies root causes, and applies fixes. Use proactively when test results contain failures.

Combined explore+brainstorm+plan agent for fdispatch pipeline. Single opus agent that explores the codebase, brainstorms approaches, and writes a structured implementation plan.

Reads review issues from state.reviewFix and applies fixes directly. Replaces inline review-fix logic in the orchestrator.

Use proactively to initialize workflow state, schedule, and directories using Claude reasoning (standard dispatch only — fdispatch initializes state inline)

Task executor for medium complexity tasks — direct execution with opus model. Reads codebase, writes code, writes tests, simplifies.

Aggregates parallel planner outputs and architecture blueprint into a unified implementation plan. Use after all planner and architecture-analyst agents have written their temp files.

Creates detailed implementation plans with task decomposition. Use proactively to break down brainstorm results into executable tasks - dispatched as parallel batch (1-10 agents).

Analyzes workflow metrics after completion — restart history, fix attempts, coverage loops, Codex fallbacks — and writes project-specific learnings to CLAUDE.md

Aggregates parallel reviewer outputs into a single review JSON. Use after all reviewer agents have written their temp files.

Reviews implemented code for simplification opportunities and applies improvements. Use proactively after implementation to reduce complexity.

Aggregates and ranks parallel solution proposals with trade-off analysis. Use after all solution-proposer agents have written their temp files.

Proposes a specific solution approach for a bug based on exploration findings. Dispatched as parallel batch (3-5 agents) to generate diverse solutions.

Task executor for easy complexity tasks — direct execution with sonnet model. Reads codebase, writes code, writes tests, simplifies.

Reviews test coverage completeness, identifies critical gaps, and checks edge cases.

Writes tests and CI configuration iteratively until coverage threshold is met. Use proactively after initial test run reveals coverage gaps.

Runs lint and test commands, captures results as structured JSON, and analyzes failures. Use proactively to validate code changes.

Analyzes type design quality — encapsulation, invariant expression, type safety.

Load, merge, and validate subagents configuration from global and project files

Manage workflow state in .agents/tmp/state.json with atomic writes

Ralph-style orchestrator loop — dispatches each phase as a subagent, hooks enforce progression

8 hooks across 4 events