Skip to content
/

Harness (revfactory) — Team-Architecture Factory

revfactory-harness · revfactory/harness · ★ 3.6k · last commit 2026-05-15

Generates domain-specific agent teams and their skills from a natural language domain description, using one of 6 pre-defined architecture patterns.

Best whenAll generated agents should use Claude Opus — harness quality is directly tied to agent reasoning capability.
Skip ifInline agent prompts (roles must be in .claude/agents/ files), Static harnesses (must evolve after each run)
vs seeds
bmad-method(persona-based multi-agent) but generates custom personas per domain rather than shipping fixed ones. The L3/L2/L1 ecosy…
Primitive shape 1 total
Skills 1
00

Summary

revfactory Harness — Summary

Harness by revfactory is a "meta-factory" Claude Code plugin: a single skill (harness/SKILL.md) that, when invoked, analyzes the user's domain and generates a custom agent team with specialized skill files tailored to that domain. Rather than being a harness itself, it is a harness generator — the output is .claude/agents/ and .claude/skills/ files configured for the user's specific project. The framework defines 6 architectural team patterns (Pipeline, Fan-out/Fan-in, Expert Pool, Producer-Reviewer, Supervisor, Hierarchical Delegation) and guides the selection based on domain analysis. Agent teams are the default; all agents use model: "opus" for maximum quality. The framework self-identifies as "L3 Meta-Factory / Team-Architecture Factory" and explicitly references ECC (L2 cross-harness) and Archon (L3 runtime-config factory) as co-existing tools. Stars: 3,552. Differs from seeds: no seed is a harness generator — all seeds ARE harnesses. The closest analogy is BMAD-METHOD (persona-based multi-agent) but BMAD ships fixed personas, while this generates custom ones per domain from scratch.

01

Overview

revfactory Harness — Overview

Origin

GitHub: https://github.com/revfactory/harness
Stars: 3,552
License: Apache-2.0
Language: HTML (documentation)
Last commit: 2026-05-15
Multilingual: English, Korean, Japanese

Philosophy

From README:

"Harness is a team-architecture factory for Claude Code. Say 'build a harness for this project' and the plugin turns your domain description into an agent team and the skills they use — picked from six pre-defined team-architecture patterns."

The key insight: "harness" is not a set of pre-built skills/commands but an architecture that generates them. The framework treats agent team design as a learnable craft with named patterns, not a free-form task.

Self-Positioning

From README:

"Harness lives at the L3 Meta-Factory layer of the Claude Code ecosystem — the layer that generates other harnesses rather than being one."

Layer taxonomy explicitly called out:

  • L3 Meta-Factory / Team-Architecture Factory (Harness itself)
  • L3 Meta-Factory / Runtime-Configuration Factory (Archon)
  • L2 Cross-Harness Workflow (ECC/affaan-m)

Manifesto-Style Quotes

"Inside L3, we pick a specific sub-layer: Team-Architecture Factory." "All agents use model: 'opus'. Harness quality is directly tied to agent reasoning ability." "The harness is not a static artifact — it is an evolving system. Incorporate feedback after every run."

Key Design Decisions

  1. Agent teams as default: 2+ agents → team-first; subagents only when team overhead exceeds benefit.
  2. Opus everywhere: all generated agents default to the most capable model.
  3. Iterative evolution: the harness is registered in CLAUDE.md for cross-session continuity; updated after each run.
  4. Phase 0 audit: before generating anything, audit existing harness state and detect drift.
02

Architecture

revfactory Harness — Architecture

Distribution

Claude Code plugin marketplace:

/plugin marketplace add revfactory/harness
/plugin install harness@harness

Also installable as a direct global skill:

cp -r skills/harness ~/.claude/skills/harness

Directory Tree

harness/
├── .claude-plugin/
│   └── plugin.json             # Plugin manifest
├── .github/
├── skills/
│   └── harness/
│       ├── SKILL.md            # Main 6-phase workflow
│       └── references/
│           ├── agent-design-patterns.md   # 6 architectural patterns + decision trees
│           ├── orchestrator-template.md   # Team/subagent orchestrator templates
│           ├── team-examples.md           # 5 real-world team configurations
│           ├── skill-writing-guide.md     # Skill authoring guide
│           ├── skill-testing-guide.md     # Testing + evaluation methodology
│           └── qa-agent-guide.md          # QA agent integration guide
├── _workspace/                 # Generated workspace artifacts
├── docs/
├── README.md
└── README_KO.md / README_JA.md

Required Runtime

  • Claude Code (plugin marketplace)

Target AI Tools

Claude Code (primary). The meta-factory generates agents/skills for Claude Code's native formats.

03

Components

revfactory Harness — Components

Skills (1 + 6 references)

Name Purpose
harness/SKILL.md Main 6-phase generation workflow
references/agent-design-patterns.md 6 patterns + decision trees + isolation criteria
references/orchestrator-template.md Team and subagent orchestrator code templates
references/team-examples.md 5 real-world team configurations
references/skill-writing-guide.md How to write skills for generated agents
references/skill-testing-guide.md Testing and evaluation methodology
references/qa-agent-guide.md QA agent design guidance

Generated Output (per invocation)

Output Location
Agent definitions project/.claude/agents/{name}.md
Skill files project/.claude/skills/{name}/SKILL.md
CLAUDE.md pointer Harness registration in project CLAUDE.md

6 Architectural Patterns

Pattern When to use
Pipeline Sequential dependent tasks
Fan-out/Fan-in Parallel independent tasks
Expert Pool Context-dependent selective invocation
Producer-Reviewer Generation followed by quality review
Supervisor Central agent with dynamic task distribution
Hierarchical Delegation Top-down recursive delegation

Execution Modes (generated agents)

Mode Mechanism Use case
Agent Teams (default) TeamCreate + SendMessage + TaskCreate 2+ agents with inter-agent communication
Subagents (alternative) Agent tool direct invocation Single-agent, result-only return
Hybrid Phase-by-phase selection Mixed requirements per phase
05

Prompts

revfactory Harness — Prompts

Excerpt 1: SKILL.md — Core Principles

Technique: Numbered operating principles + evolution mandate

핵심 원칙:
1. 에이전트 정의(`.claude/agents/`)와 스킬(`.claude/skills/`)을 생성한다.
2. **에이전트 팀을 기본 실행 모드로 사용한다.**
3. **CLAUDE.md에 하네스 포인터를 등록한다.** — 새 세션에서 오케스트레이터 스킬이 트리거되도록 최소한의 포인터(트리거 규칙 + 변경 이력)만 기록한다.
4. **하네스는 고정물이 아니라 진화하는 시스템이다.** — 매 실행 후 피드백을 반영하고, 에이전트·스킬·CLAUDE.md를 지속 갱신한다.

Translation: "(1) Generate agent definitions and skill files. (2) Use agent teams as the default execution mode. (3) Register harness pointers in CLAUDE.md. (4) The harness is not a static artifact — it is an evolving system."

Excerpt 2: Phase 3 — Agent quality requirements

Technique: Absolute prohibition with rationale

**모든 에이전트는 반드시 `프로젝트/.claude/agents/{name}.md` 파일로 정의한다.** 에이전트 정의 파일 없이 Agent 도구의 prompt에 역할을 직접 넣는 것은 금지한다.

이유:
- 에이전트 정의가 파일로 존재해야 다음 세션에서 재사용 가능
- 팀 통신 프로토콜이 명시되어야 에이전트 간 협업 품질 보장
- 하네스의 핵심 가치는 에이전트(누가)와 스킬(어떻게)의 분리

Translation: "All agents MUST be defined as project/.claude/agents/{name}.md files. Putting role descriptions directly in the Agent tool prompt is prohibited. Reasons: files enable reuse across sessions; explicit team protocols ensure collaboration quality; separating agent (who) from skill (how) is the core harness value."

Excerpt 3: Model mandate

Technique: Quality-linked model requirement

**모델 설정:** 모든 에이전트는 `model: "opus"`를 사용한다. Agent 도구 호출 시 반드시 `model: "opus"` 파라미터를 명시한다. 하네스의 품질은 에이전트의 추론 능력에 직결되며, opus가 최고 품질을 보장한다.

Translation: "All agents use model: 'opus'. Harness quality is directly tied to agent reasoning ability, and opus guarantees the highest quality."

09

Uniqueness

revfactory Harness — Uniqueness

differs_from_seeds

No seed is a harness generator — all 11 seeds ARE harnesses. The closest is BMAD-METHOD (Archetype 1, persona-based multi-agent with named subagents) but BMAD ships fixed personas while this generates custom domain-specific ones. Also resembles superpowers in using skills-only behavioral framework (single skill, no commands), but superpowers' skills enforce development discipline while this skill generates other skills. The self-aware L3/L2/L1 layer taxonomy explicitly positions this relative to ECC (named as a co-existing L2 tool), making it unique as the only framework in the catalog that explicitly maps its own position in a framework ecosystem.

Most Distinctive Features

  1. Meta-factory: generates other harnesses rather than being one.
  2. Opus mandate: all generated agents hardcoded to the most capable model.
  3. 6-pattern taxonomy: explicit names for team architecture patterns used as a design vocabulary.
  4. Drift detection: Phase 0 audit prevents harness rot over time.

Observable Failure Modes

  1. Cost: all-opus generated teams are expensive — each agent spawned will cost more than a haiku or sonnet invocation.
  2. Korean-first documentation: the primary SKILL.md is in Korean; reference materials may be Korean-only.
  3. Generated harness quality depends on generation quality: a poorly described domain produces a poor harness.
  4. CLAUDE.md coupling: the harness pointer in CLAUDE.md can conflict with other plugins that also modify CLAUDE.md.
04

Workflow

revfactory Harness — Workflow

6-Phase Generation Workflow

Phase 0: Audit → Phase 1: Domain Analysis → Phase 2: Architecture Design
→ Phase 3: Agent Definition Generation → Phase 4: Skill Generation
→ Phase 5: Integration & Orchestration → Phase 6: Validation & Testing

Phase Details

Phase Action Artifact Gate
0: Audit Read existing .claude/agents/, .claude/skills/, CLAUDE.md; detect drift audit report User confirms execution plan
1: Domain Analysis Extract core task types, detect complexity, user skill level domain model none
2: Architecture Design Select execution mode + pattern; define agent separation criteria architecture doc none
3: Agent Generation Write .claude/agents/{name}.md for each agent agent definition files none
4: Skill Generation Write .claude/skills/ for each agent skill files none
5: Integration Write orchestrator skill; register in CLAUDE.md orchestrator + CLAUDE.md update none
6: Validation Trigger verification, dry-run, with-skill vs without-skill comparison test results none

Phase 0 Dispatch Matrix (for existing harness)

Change type Phases run
Add agent Phase 0 result → 2 (deploy only) → 3 (new agent) → 4 (if new skill) → 5 → 6
Add/modify skill Phase 0 → 4 → 6
Architecture change Phase 0 → 2 → affected agents → affected skills → 5 → 6

Approval Gates

  1. Phase 0: user confirms execution plan (audit result + what Harness will do).
  2. Implicit: agent team design requires user to trigger "build a harness for this project."

Generated Agent Quality Rules

  • All agents MUST be defined as files (not inline in Task tool prompts)
  • All agents MUST use model: "opus"
  • Teams of 2+ MUST use Agent Teams mode (not subagents) unless overhead clearly outweighs benefit
06

Memory Context

revfactory Harness — Memory & Context

State Storage

  • Generated agent definitions: project/.claude/agents/
  • Generated skill files: project/.claude/skills/
  • CLAUDE.md harness pointer: minimal trigger rules + change history

Cross-Session Continuity

The harness pointer in CLAUDE.md ensures that on new sessions, the orchestrator skill auto-triggers (via description-based skill matching), re-loading the generated team architecture.

Drift Detection

Phase 0 audit reads existing agents/skills/CLAUDE.md and detects drift between what's registered and what's actually present. Users are shown a diff before any changes.

Memory Type

File-based, project-scoped.

07

Orchestration

revfactory Harness — Orchestration

Multi-Agent (generated)

Yes. The harness generates multi-agent team configurations. The generated orchestrator manages inter-agent communication via TeamCreate + SendMessage + TaskCreate.

Orchestration Pattern

The meta-factory generates one of 6 patterns:

  • Pipeline, Fan-out/Fan-in, Expert Pool, Producer-Reviewer, Supervisor, Hierarchical Delegation

Multi-Model

Yes. All generated agents default to model: "opus". This is the only framework in the batch that mandates the most capable model for all subagents.

Isolation Mechanism

None at the meta-factory level. Generated agents use Claude Code's native team isolation.

Execution Mode

Interactive-loop: triggered by natural language ("build a harness for this project").

Cross-Tool Portability

Low: generates Claude Code-native .claude/ files exclusively.

08

Ui Cli Surface

revfactory Harness — UI & CLI Surface

Dedicated CLI Binary

No.

Local UI

No.

Trigger

Natural language in Claude Code:

  • "Build a harness for this project" (English)
  • "하네스 구성해줘" (Korean)
  • "ハーネスを構成して" (Japanese)

No slash command required — the skill's description triggers autonomously.

Output

Generated files written to project/.claude/agents/ and project/.claude/skills/.

Observability

Phase 0 audit report surfaces drift between expected and actual harness state.

Related frameworks

same archetype · same primary tool · same memory type

Compose-Lang ★ 3

Turns minimal architecture specs into production code via a compiler pipeline that calls an LLM backend.

Superpowers ★ 207k

Enforces spec-first, TDD, and subagent-reviewed development as mandatory automatic workflows rather than optional practices.

Claude-Flow / Ruflo ★ 55k

Eliminates single-agent context limits and sequential bottlenecks by orchestrating fault-tolerant swarms of specialized AI agents…

BMAD-METHOD ★ 48k

Provides a full agile delivery lifecycle with named expert-persona AI collaborators that elicit the human's best thinking rather…

Agent OS ★ 4.6k

Extracts implicit codebase conventions into token-efficient markdown standards files and injects them selectively into AI agent…

Claude Conductor ★ 367

Gives Claude Code a persistent, cross-linked, auto-analyzed documentation system so it retains codebase context across sessions.