Harness: A Multi-Agent Workflow Orchestration Tool Based on Claude Code

Harness is an open-source CLI tool that automatically decomposes tasks via natural language descriptions and drives multiple Claude agents to collaborate on development work. It implements a complete pipeline of research, planning, review, implementation, testing, and validation, supporting parallel execution and failure retry mechanisms, thus providing an automated solution for complex software development tasks.

In traditional development processes, developers need to manually switch between stages such as requirement analysis, architecture design, and code implementation, which is complex and limits efficiency. Harness's design philosophy stems from solving this pain point: it automates processes by introducing specialized agent roles while retaining human review and decision-making links. Its hybrid model (automated execution + human supervision) ensures controllable efficiency and quality—generating a detailed technical specification before execution, which waits for human review and approval.

Harness defines 7 specialized agent roles:

1. Planner (Opus model): Decomposes tasks into subtasks with dependencies and generates a roadmap;
2. Implementer (Opus model): Converts subtasks into code implementations;
3. Tester: Writes and runs test cases;
4. Validator: Confirms whether acceptance criteria are met;
5. Analyzer: Scans existing code to identify areas requiring research;
6. Researcher: Conducts in-depth analysis of code areas and generates documentation;
7. Jira Context Retriever (Sonnet model): Retrieves ticket details from Jira, enabling integration with enterprise project management processes.

Harness's workflow consists of four key stages:

• Research Phase: The Analyzer scans existing code, and the Researcher generates detailed documentation to provide context for planning;
• Planning Phase: The Planner combines task descriptions, Jira context (if configured), and research documentation to output a DAG of subtasks with dependencies;
• Review Phase: Generates a specification for human review (can be approved, modified, or exited), and after approval, it is saved to the .harness/specs/ directory;
• Execution Phase: The DAG engine executes independent subtasks in parallel (implementation → testing → validation), retries up to 3 times on failure, and blocks downstream dependencies if it fails.

Harness's main technical features include:

• Parallel Execution: Based on the DAG structure, independent subtasks can run in parallel, reducing overall time;
• Failure Retry and Cascading Blocking: Subtasks are retried up to 3 times on failure; if they eventually fail, downstream dependencies are blocked;
• Specification Persistence: Saves the specification for each run, facilitating auditing and debugging;
• CI/CD Integration: The --auto-approve flag allows skipping the review step in CI environments, enabling seamless integration with automated processes.

Applicable Scenarios:

• New feature development (from natural language requirements to complete implementation);
• Code refactoring (safe refactoring based on existing code);
• Test coverage supplementation (automatically generating test cases);
• Rapid prototype validation (verifying the feasibility of technical solutions).

Installation Requirements: Node.js 20+, Claude Code CLI, AWS Bedrock access (configure aliases for Opus and Sonnet models).

Basic Usage: harness run "Build a REST API with input validation and a database layer", supporting --dry-run (planning only) and --auto-approve (auto-approval) modes.

Harness represents an important direction in AI-assisted development: shifting from code completion to full task automation. It demonstrates how to organize multi-agent collaboration to handle complex development workflows, improving efficiency while ensuring quality through human review. In the future, as model capabilities improve, similar tools may become standard components of the development toolchain, further changing software development patterns.