You have Claude Code. You want to build something ambitious — a deep research pipeline, a full-stack app scaffold, a code review system. You could wire up agents manually, writing each definition by hand. Or you could type "build a harness for this project" and let Harness do it.
Harness is a Claude Code plugin that takes a plain-English description of what you want to build and produces a ready-to-run agent team: the agent definitions, the skill files, the orchestration logic — all of it.
What Problem Does It Solve?
Multi-agent work in Claude Code requires a lot of upfront scaffolding. You need to:
- define each agent's role and responsibilities in a
.claude/agents/markdown file - write skill files in
.claude/skills/that describe how tasks get done - decide how agents communicate and hand off work
- handle error cases and validation
For a non-trivial project, this is several hours of work before you have written a line of actual code. Harness compresses that into a single conversational prompt.
The Six Architecture Patterns
Harness does not just dump agents into a folder. It picks one of six battle-tested team structures based on your domain:
Pipeline — agents run in sequence, each one feeding into the next. Good for anything with clear stages: plan, write, test, deploy.
Fan-out/Fan-in — a coordinator spawns parallel agents, collects their results, and merges them. Good for research or code review where independent threads can run simultaneously.
Expert Pool — agents are specialists invoked selectively based on what the current task needs. Good for domains with diverse sub-problems.
Producer-Reviewer — one agent generates, another critiques. Good for content creation, documentation, or anything where quality gates matter.
Supervisor — a central agent dynamically routes tasks to workers based on what needs to happen next. Good for open-ended workflows.
Hierarchical Delegation — top-down recursive delegation where complex tasks get broken down through multiple layers. Good for large-scale engineering or project management.
Harness reads your description and picks the pattern that fits best. You can also guide it explicitly.
Setup
Prerequisites
You need Claude Code installed and agent teams enabled. Agent teams are still behind a feature flag:
export CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1
Add that to your shell profile (.zshrc, .bashrc, etc.) so it persists.
Install via Plugin Marketplace
Inside Claude Code, run:
/plugin marketplace add revfactory/harness
Then:
/plugin install harness@harness
That's it. The plugin is now globally available in your Claude Code sessions.
Install Manually (Global Skill)
If you prefer to manage things yourself, clone the repo and copy the skill directly:
git clone https://github.com/revfactory/harness.git
cp -r harness/skills/harness ~/.claude/skills/harness
This drops the skill files into Claude Code's global skill directory and makes them available in any project.
Using It
Once installed, trigger it with a natural language prompt inside Claude Code. There is no special syntax — just describe what you want.
Example: deep research agent team
Build a harness for deep research. I need an agent team that can investigate
any topic from multiple angles — web search, academic sources, community
sentiment — then cross-validate findings and produce a comprehensive report.
Example: code review pipeline
Build a harness for comprehensive code review. I want parallel agents
checking architecture, security vulnerabilities, performance bottlenecks,
and code style — then merging all findings into a single report.
Example: full-stack development
Build a harness for full-stack website development. The team should handle
design, frontend (React/Next.js), backend (API), and QA testing in a
coordinated pipeline from wireframe to deployment.
After you run one of these, Harness generates files in your project:
your-project/
├── .claude/
│ ├── agents/
│ │ ├── analyst.md
│ │ ├── builder.md
│ │ └── qa.md
│ └── skills/
│ ├── analyze/
│ │ └── SKILL.md
│ └── build/
│ ├── SKILL.md
│ └── references/
The agent files define each agent's persona, capabilities, and constraints. The skill files define the step-by-step procedures each agent follows. You can read and edit every file — nothing is a black box.
What the Six-Phase Workflow Looks Like
Harness does not just dump files. It runs a structured process:
- Domain Analysis — it reads your prompt and identifies the key actors, inputs, and outputs
- Team Architecture Design — it picks the right pattern from the six and sketches the team structure
-
Agent Definition Generation — it writes the
.claude/agents/markdown files -
Skill Generation — it writes the
.claude/skills/files with Progressive Disclosure (loading only what context is needed, when it is needed) - Integration and Orchestration — it wires inter-agent data passing and error handling
- Validation and Testing — it sets up trigger verification and dry-run tests
Is It Worth It?
The repo includes A/B test results from a companion repository (revfactory/claude-code-harness) covering 15 software engineering tasks:
| Metric | Without Harness | With Harness |
|---|---|---|
| Average Quality Score | 49.5 / 100 | 79.3 / 100 |
| Win Rate | — | 15 out of 15 |
| Output Variance | — | -32% |
The improvement scaled with task complexity: +23.8 points on basic tasks, +29.6 on advanced, +36.2 on expert-level tasks. The more difficult the problem, the more structure helps.
One important caveat: this is an author-measured study with n=15, and third-party replications have not yet been published.
Where it clearly helps:
- You are starting a new project and want agent scaffolding without spending hours on definitions
- Your task has multiple distinct sub-problems that map cleanly onto a team pattern
- You want to experiment with different team architectures quickly
- You are building something complex enough that ad-hoc prompting produces inconsistent results
What Gets Generated vs What You Maintain
Harness generates a starting point. The files it creates are plain markdown — readable, editable, version-controllable. You own them after generation.
Ecosystem Fit
Harness is Claude Code-native. It does not work with Gemini CLI or Codex out of the box — a Codex port called meta-harness exists for that.
If you are using LangGraph for state-recoverable, long-running orchestration, Harness is not a replacement. LangGraph handles persistent state and recovery across sessions; Harness handles team architecture design within Claude Code. They occupy different layers.
Quick Reference
# Enable agent teams
export CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1
# Install via plugin marketplace
/plugin marketplace add revfactory/harness
/plugin install harness@harness
# Or manually
cp -r skills/harness ~/.claude/skills/harness
# Use it
"Build a harness for [your domain]"
Verdict
Harness solves a real problem. Multi-agent scaffolding is tedious to write from scratch, easy to get wrong, and hard to keep consistent. Harness handles the structural work so you can focus on the domain logic.
Repository: github.com/revfactory/harness
License: Apache 2.0
Top comments (0)