English | 한국어
codex-harness is a team-architecture factory for OpenAI Codex. Say "build a harness for this project" (English) or "하네스 구성해줘" (한국어), and the skill turns your domain description into an Orchestrator Thread + specialist Agent Threads and the reusable skills they use — picked from six pre-defined team-architecture patterns and emitted onto Codex-native surfaces only.
codex-harness decomposes complex, recurring work into a coordinated team of specialized agents — but where the original revfactory/harness maps that team onto Claude Code's agent-team runtime, codex-harness maps it onto the surface Codex actually runs on: the Codex Thread.
A Thread is treated as the first-class execution boundary — a durable specialist room with its own isolated context, role identity, and handoff report. The harness scaffolds these threads, the skills they run, and the file-mediated state that lets them hand work to each other. Point it at a project, ask it to "build a harness," and it generates everything on Codex surfaces only — AGENTS.md, .agents/skills/, .agents/agents/, .codex/config.toml, Codex Threads, codex exec, sandbox/approval policy, MCP, and optional hooks. No .claude/, no CLAUDE.md, no Claude-specific orchestration tools.
codex-harness lives at the L3 Meta-Factory layer — the layer that generates other harnesses rather than being one. Inside L3 it occupies the Team-Architecture Factory sub-layer, the same one as revfactory/harness, but bound to a different runtime.
| Layer | What it does | Runtime |
|---|---|---|
| L3 — Meta-Factory / Team-Architecture Factory (us) | Domain sentence → Orchestrator Thread + Agent Threads + skills, via 6 team patterns | OpenAI Codex (Threads) |
| L3 — Meta-Factory / Team-Architecture Factory | Same concept, Claude-native agent teams | revfactory/harness |
| L3 — Meta-Factory / Runtime-Configuration Factory | Deterministic, repeatable runtime configurations | coleam00/Archon |
revfactory/harnessgenerates Claude-Code agent teams. codex-harness generates the same six team architectures (pipeline, fan-out/fan-in, expert pool, producer-reviewer, supervisor, hierarchical delegation) plus the skills agents use — but as Codex Threads with file-mediated handoff. Same sub-layer, different runtime. Pickrevfactory/harnessfor Claude Code, codex-harness for Codex.
- Thread-Native Team Design — 6 architectural patterns (Pipeline, Fan-out/Fan-in, Expert Pool, Producer-Reviewer, Supervisor, Hierarchical Delegation) mapped onto an Orchestrator Thread + Agent Threads.
- Expert-Level Roles, Not Generic Doers — Every agent role must encode professional judgment: expert heuristics, decision rules, anti-patterns, domain quality bars, and (for research roles) a search/query strategy. The harness asks you at consequential decision points instead of assuming.
- Skill Generation — Auto-generates reusable skills with Progressive Disclosure (
references/,templates/,scripts/) for efficient context management. - File-Mediated Orchestration —
_workspace/carries thread briefs, handoff reports, merge inputs, and decisions across sessions, making threads durable and partial reruns possible. - Codex-Native Safety — Risk is bounded by sandbox/profile/hook policy and
config.tomlprofiles, not by prose alone. - Validation — Trigger verification, dry-run scenarios, thread-board checks, and integration-coherence checks.
Phase 0: Audit existing harness
↓
Phase 1: Domain & recurring-work analysis → _workspace/00_requirements.md
↓
Phase 2: Execution-mode selection (smallest useful runtime)
↓
Phase 3: Architecture-pattern selection (6 patterns)
↓
Phase 4: Agent role definition → .agents/agents/<role>.md
↓
Phase 5: Skill generation → .agents/skills/<skill>/SKILL.md
↓
Phase 6: Orchestrator skill generation → .agents/skills/<domain>-orchestrator/
↓
Phase 7: Thread workspace → _workspace/
↓
Phase 8: AGENTS.md pointer update
↓
Phase 9: Optional Codex automation (codex exec / hooks / MCP)
↓
Phase 10: Validation
↓
Phase 11: Evolution
codex-harness preserves the Harness concept but supplies the runtime mapping Codex needs. The best Codex port is not "Claude agent team → codex exec scripts." It is "Claude agent team → Codex Thread team + file-mediated handoff + optional codex exec automation + optional subagents + optional hooks."
| Harness concept | Claude-native implementation | Codex thread-native implementation |
|---|---|---|
| Orchestrator | Team / manager agent | Orchestrator Thread |
| Specialist agent | .claude/agents + team messaging |
Agent Thread + role file + skill |
| Message protocol | SendMessage / TaskCreate |
Thread briefs + handoff reports |
| Shared state | Team task state | _workspace/ + thread board |
| Parallelism | Agent/team runtime | Multiple Codex Threads or codex exec jobs |
| Review gates | Team protocol + QA agents | Phase gates in the Orchestrator Thread |
| Evolution | /harness:evolve |
Harness maintenance + change history |
The skill lives at skills/harness/. Install it where Codex discovers skills — globally for all projects, or per-project.
git clone https://github.com/namojo/codex-harness.git
mkdir -p ~/.agents/skills
cp -r codex-harness/skills/harness ~/.agents/skills/harnessOr keep it updatable with a symlink:
git clone https://github.com/namojo/codex-harness.git ~/codex-harness
ln -s ~/codex-harness/skills/harness ~/.agents/skills/harness
# update later with: git -C ~/codex-harness pullmkdir -p .agents/skills
cp -r /path/to/codex-harness/skills/harness .agents/skills/harnessAfter installing, confirm Codex can see it — skills/harness/SKILL.md carries the frontmatter name: harness.
codex-harness/
├── README.md
├── LICENSE
└── skills/
└── harness/
├── SKILL.md # Main skill (12-phase, Phase 0–11)
├── templates/
│ ├── thread-brief.md # Copy-paste prompt for an Agent Thread
│ └── thread-report.md # Standardized handoff report
├── examples/
│ └── newsletter-thread-harness.md
└── references/
├── codex-thread-native-architecture.md # Threads as agent runtime
├── codex-thread-orchestration-protocol.md # board, brief, report, gates
├── codex-agent-patterns-thread-native.md # 6 patterns, thread-mapped
├── codex-orchestrator-template-thread-native.md
├── codex-native-surfaces.md # sandbox, config.toml, exec, MCP
├── codex-expertise-and-quality.md # expert judgment, query strategy, gate rubrics
├── codex-skill-writing-guide.md
└── codex-skill-testing-guide.md
In a Codex session, ask in natural language. Triggering phrases include:
Build a harness for this project
Design a thread-native orchestrator and specialist agent threads for this workflow
Convert this recurring workflow into a Codex multi-thread harness
Design an agent team / subagent workflow for <domain>
Extend the harness — add a <role> agent / a <task> skill
Audit / repair / sync the harness (maintenance mode)
The skill runs: audit → domain analysis → execution-mode selection → thread-native architecture → agent roles → skills → orchestrator → thread workspace → AGENTS.md → optional automation → validation → evolution. It reports the architecture, the files it created, validation evidence, and the copy-paste prompts you use to run the harness.
The harness picks the smallest useful runtime.
| Mode | Use when | Runtime shape |
|---|---|---|
| Single Thread | small or sequential task | one Codex Thread + skills |
| Thread-Orchestrated Team (default) | recurring, role-separated, parallel, context-heavy work | Orchestrator Thread + Agent Threads |
Hybrid Thread + codex exec |
repeatable CLI checks or independent review jobs | threads coordinate, exec automates |
| Subagent-in-Thread | host exposes subagents and the task is bounded | agent thread uses subagents internally |
| Scheduled Harness | recurring unattended read-only work | external scheduler + codex exec + _workspace/ |
Default to Thread-Orchestrated Team when the user explicitly asks for multi-agent, multi-thread, orchestrator, team, fan-out/fan-in, or harness behavior.
| Pattern | Description | Thread-native mapping |
|---|---|---|
| Pipeline | Sequential dependent tasks | phase-by-phase Threads/skills run in order |
| Fan-out/Fan-in | Parallel independent tasks | parallel Agent Threads; Orchestrator merges reports |
| Expert Pool | Context-dependent selective invocation | spawn a specialist Thread only when needed |
| Producer-Reviewer | Generation followed by quality review | separate authoring Thread from review Thread |
| Supervisor | Central agent, dynamic task distribution | Orchestrator spawns new briefs as it explores |
| Hierarchical Delegation | Top-down recursive delegation | sub-orchestrator Threads manage sub-teams |
Files generated by codex-harness (artifact bodies are written in Korean by default — name frontmatter, code, paths, and settled technical terms stay as-is):
your-project/
├── AGENTS.md # routing rule, thread orchestration, safety policy, change history
├── .agents/
│ ├── agents/ # durable specialist role definitions
│ │ ├── analyst.md
│ │ ├── builder.md
│ │ └── reviewer.md
│ └── skills/ # reusable skills (the "how")
│ ├── <domain>-orchestrator/
│ │ └── SKILL.md # Orchestrator Thread skill: brief, gate, merge, evolve
│ └── <task>/
│ ├── SKILL.md
│ └── references/
└── _workspace/ # file-mediated handoff state
├── 00_requirements.md
├── 01_thread_board.md
├── 02_thread_briefs/
├── 03_thread_reports/
├── 04_merge_inputs/
└── 90_decisions.md
Copy any prompt below into a Codex session after installing codex-harness:
Deep Research
Build a harness for deep research. I need an Orchestrator Thread that fans out
to specialist Agent Threads — web search, academic sources, community sentiment —
then cross-validates findings through a review gate and merges a cited report.
Website Development
Build a harness for full-stack website development. The team should handle
design, frontend (React/Next.js), backend (API), and QA in a coordinated
pipeline of threads, handing off through _workspace/ from wireframe to deploy.
Newsletter / Content Production
Build a thread-native harness for a weekly newsletter: research, drafting,
editing, and fact-check threads that hand off through _workspace/, with the
Orchestrator Thread gating each phase before publish.
Code Review & Refactoring
Build a harness for comprehensive code review. I want parallel Agent Threads
checking architecture, security, performance, and style, plus codex exec jobs
for independent read-only audits — then merged into a single report.
Technical Documentation
Build a harness that generates API documentation from this codebase. Threads
should analyze endpoints, write descriptions, generate usage examples, and run
a completeness review gate before merge.
Recurring Ops / Scheduled Harness
Convert this recurring read-only check into a scheduled harness: an external
scheduler runs codex exec jobs, writes results into _workspace/, and an
Orchestrator Thread reviews the board on demand.
- Codex Threads are execution boundaries. A thread can be a durable specialist room with isolated context, role identity, and a handoff report.
- The Orchestrator is a thread. It owns decomposition, routing, phase gates, merge decisions, partial reruns, and evolution.
- File-mediated state makes threads durable.
_workspace/carries thread briefs, reports, merge inputs, and decisions across sessions. codex execis an automation spine, not the whole runtime. Use it for independent reviews, structured extraction, read-only audits, and batch checks.- Safety is enforced, not described. Each automated step's risk is bounded by sandbox/profile/hook policy. Durable roles map to
config.tomlprofiles, external tools register as MCP servers, andAGENTS.mdis used hierarchically.
| Repo | Their position | Relationship to codex-harness |
|---|---|---|
| revfactory/harness | Team-Architecture Factory on Claude Code | Same sub-layer, different runtime. codex-harness is the Codex Thread-native edition of this concept. Use harness on Claude Code, codex-harness on Codex. |
| coleam00/Archon | Deterministic runtime-configuration factory | Same L3, neighbor sub-layer. Archon for runtime determinism, codex-harness for thread-team architecture, or combine them. |
Q1. How is this different from just writing codex exec scripts?
A. A pile of codex exec scripts has no durable context, no role identity, and no handoff protocol. codex-harness treats each Codex Thread as a specialist room with its own context and a standardized handoff report, coordinated by an Orchestrator Thread through _workspace/. codex exec is still used — as an automation spine for independent reviews, structured extraction, and read-only audits — but it supports the threads rather than replacing them.
Q2. Is this a fork of revfactory/harness?
A. It's a Codex-native port of the concept, not a fork of the implementation. It keeps the six team-architecture patterns, the skill-generation craft, and the validate/evolve loop, but emits Codex surfaces only (AGENTS.md, .agents/, Codex Threads, codex exec, sandbox/approval policy, MCP, hooks) and adds the runtime mapping in the table above. It never produces .claude/, CLAUDE.md, or Claude-specific orchestration tools.
Q3. Do I always get a multi-thread team?
A. No. The harness picks the smallest useful runtime — a small or sequential task gets a Single Thread. It only builds an Orchestrator + Agent Threads when there's genuine role separation, parallelism, independent review, long context, or recurrence. See the Execution Modes table.
MIT — see LICENSE. Concept adapted from revfactory/harness.
English | 한국어
codex-harness는 OpenAI Codex를 위한 팀 아키텍처 팩토리입니다. "하네스 구성해줘" 또는 **"build a harness for this project"**라고 말하면, 스킬이 도메인 설명을 Orchestrator Thread + 전문 Agent Threads와 그들이 사용할 재사용 스킬로 바꿔 줍니다 — 6가지 사전 정의된 팀 아키텍처 패턴 중에서 선택하며, Codex 네이티브 표면에만 생성합니다.
codex-harness는 복잡하고 반복적인 업무를 전문 에이전트 팀으로 분해합니다. 다만 원본인 revfactory/harness가 그 팀을 Claude Code의 에이전트 팀 런타임에 매핑하는 반면, codex-harness는 Codex가 실제로 동작하는 표면인 Codex Thread에 매핑합니다.
Thread는 1급 실행 단위로 취급됩니다 — 독립된 맥락, 역할 정체성, 핸드오프 보고를 가진 durable한 전문 작업실입니다. 하네스는 이 스레드들, 그 안에서 실행할 스킬, 그리고 스레드끼리 작업을 주고받게 해 주는 파일 매개 상태를 스캐폴딩합니다. 프로젝트를 가리키며 "하네스 만들어줘"라고 하면, 모든 것을 Codex 표면(AGENTS.md, .agents/skills/, .agents/agents/, .codex/config.toml, Codex Threads, codex exec, 샌드박스/승인 정책, MCP, 선택적 hooks)에만 생성합니다. .claude/, CLAUDE.md, Claude 전용 오케스트레이션 도구는 만들지 않습니다.
codex-harness는 L3 Meta-Factory 계층 — 다른 하네스를 만들어 내는 계층 — 에 있습니다. L3 안에서는 revfactory/harness와 동일한 Team-Architecture Factory 서브 계층에 속하되, 런타임이 다릅니다.
| 계층 | 하는 일 | 런타임 |
|---|---|---|
| L3 — Meta-Factory / Team-Architecture Factory (우리) | 도메인 문장 → Orchestrator Thread + Agent Threads + 스킬, 6가지 팀 패턴 | OpenAI Codex (Threads) |
| L3 — Meta-Factory / Team-Architecture Factory | 같은 개념, Claude 네이티브 에이전트 팀 | revfactory/harness |
| L3 — Meta-Factory / Runtime-Configuration Factory | 결정론적이고 반복 가능한 런타임 설정 | coleam00/Archon |
revfactory/harness는 Claude Code 에이전트 팀을 만듭니다. codex-harness는 동일한 6가지 팀 아키텍처(pipeline, fan-out/fan-in, expert pool, producer-reviewer, supervisor, hierarchical delegation)와 스킬을 만들되 파일 매개 핸드오프를 가진 Codex Thread로 구현합니다. 같은 서브 계층, 다른 런타임. Claude Code면revfactory/harness, Codex면 codex-harness를 선택하세요.
- Thread-Native 팀 설계 — 6가지 아키텍처 패턴(Pipeline, Fan-out/Fan-in, Expert Pool, Producer-Reviewer, Supervisor, Hierarchical Delegation)을 Orchestrator Thread + Agent Threads로 매핑.
- 전문가 수준 역할 (generic doer 금지) — 모든 에이전트 역할은 전문가 판단 기준을 내장한다: 전문가 휴리스틱, 의사결정 규칙, 안티패턴, 도메인 품질 기준선, (리서치 역할은) 검색·쿼리 전략. 하네스는 결과를 좌우하는 결정 지점에서 가정 대신 사용자에게 묻는다.
- 스킬 생성 — Progressive Disclosure(
references/,templates/,scripts/)를 적용한 재사용 스킬을 자동 생성해 맥락을 효율적으로 관리. - 파일 매개 오케스트레이션 —
_workspace/가 thread brief, handoff report, merge input, decision을 세션 너머로 보존해 스레드를 durable하게 만들고 부분 재실행을 가능하게 함. - Codex 네이티브 안전성 — 위험을 산문이 아니라 sandbox/profile/hook 정책과
config.toml프로파일로 제한. - 검증 — 트리거 검증, 드라이런 시나리오, thread-board 검증, 통합 정합성 검증.
Phase 0: 기존 하네스 점검
↓
Phase 1: 도메인·반복 업무 분석 → _workspace/00_requirements.md
↓
Phase 2: 실행 모드 선택 (가장 작은 유용한 런타임)
↓
Phase 3: 아키텍처 패턴 선택 (6가지)
↓
Phase 4: Agent 역할 정의 → .agents/agents/<role>.md
↓
Phase 5: 스킬 생성 → .agents/skills/<skill>/SKILL.md
↓
Phase 6: 오케스트레이터 스킬 생성 → .agents/skills/<domain>-orchestrator/
↓
Phase 7: Thread workspace → _workspace/
↓
Phase 8: AGENTS.md 포인터 업데이트
↓
Phase 9: 선택적 Codex 자동화 (codex exec / hooks / MCP)
↓
Phase 10: 검증
↓
Phase 11: 진화
codex-harness는 Harness의 개념을 유지하되 Codex에 필요한 런타임 매핑을 제공합니다. Codex용 최적 포팅은 "Claude 에이전트 팀 → codex exec 스크립트"가 아닙니다. "Claude 에이전트 팀 → Codex Thread 팀 + 파일 매개 핸드오프 + 선택적 codex exec 자동화 + 선택적 subagents + 선택적 hooks"입니다.
| Harness 개념 | Claude-native 구현 | Codex thread-native 구현 |
|---|---|---|
| Orchestrator | 팀장/매니저 에이전트 | Orchestrator Thread |
| Specialist agent | .claude/agents + 팀 메시징 |
Agent Thread + role 파일 + 스킬 |
| Message protocol | SendMessage / TaskCreate |
Thread brief + handoff report |
| Shared state | 팀 task state | _workspace/ + thread board |
| Parallelism | Agent/team 런타임 | 여러 Codex Thread 또는 codex exec 작업 |
| Review gate | Team protocol + QA agents | Orchestrator Thread의 phase gate |
| Evolution | /harness:evolve |
Harness maintenance + change history |
스킬 본체는 skills/harness/에 있습니다. Codex가 스킬을 인식하는 위치에 설치하세요 — 모든 프로젝트면 전역, 특정 프로젝트만이면 프로젝트별로 설치합니다.
git clone https://github.com/namojo/codex-harness.git
mkdir -p ~/.agents/skills
cp -r codex-harness/skills/harness ~/.agents/skills/harness업데이트를 쉽게 유지하려면 심볼릭 링크 방식:
git clone https://github.com/namojo/codex-harness.git ~/codex-harness
ln -s ~/codex-harness/skills/harness ~/.agents/skills/harness
# 이후 업데이트: git -C ~/codex-harness pullmkdir -p .agents/skills
cp -r /path/to/codex-harness/skills/harness .agents/skills/harness설치 후 Codex가 인식하는지 확인하세요 — skills/harness/SKILL.md에 frontmatter name: harness가 있습니다.
codex-harness/
├── README.md
├── LICENSE
└── skills/
└── harness/
├── SKILL.md # 메인 스킬 (12단계, Phase 0–11)
├── templates/
│ ├── thread-brief.md # Agent Thread에 붙여넣는 지시문
│ └── thread-report.md # 표준 핸드오프 보고서
├── examples/
│ └── newsletter-thread-harness.md
└── references/
├── codex-thread-native-architecture.md # Thread를 agent runtime으로
├── codex-thread-orchestration-protocol.md # board, brief, report, gate
├── codex-agent-patterns-thread-native.md # 6패턴, thread 매핑
├── codex-orchestrator-template-thread-native.md
├── codex-native-surfaces.md # sandbox, config.toml, exec, MCP
├── codex-expertise-and-quality.md # expert judgment, query strategy, gate rubrics
├── codex-skill-writing-guide.md
└── codex-skill-testing-guide.md
Codex 세션에서 자연어로 요청합니다. 트리거되는 표현 예시:
이 프로젝트에 하네스 만들어줘
이 워크플로우를 위한 thread-native orchestrator와 specialist agent thread를 설계해줘
이 반복 업무를 Codex multi-thread harness로 바꿔줘
<도메인>을 위한 에이전트 팀 / 서브에이전트 워크플로우 설계해줘
하네스 확장해줘 — <역할> 에이전트 / <작업> 스킬 추가
하네스 점검 / 수정 / 동기화해줘 (유지보수 모드)
스킬은 감사 → 도메인 분석 → 실행 모드 선택 → thread-native architecture → 에이전트 역할 → 스킬 → 오케스트레이터 → thread workspace → AGENTS.md → 선택적 자동화 → 검증 → 진화 순으로 동작합니다. 아키텍처, 생성한 파일, 검증 근거, 그리고 하네스를 실행할 때 붙여 넣을 프롬프트를 보고합니다.
하네스는 가장 작은 유용한 런타임을 선택합니다.
| 모드 | 언제 쓰나 | Runtime shape |
|---|---|---|
| Single Thread | 작고 순차적인 작업 | 하나의 Codex Thread + skills |
| Thread-Orchestrated Team (기본값) | 반복적, 역할 분리, 병렬, 긴 맥락 작업 | Orchestrator Thread + Agent Threads |
Hybrid Thread + codex exec |
반복 CLI 검사나 독립 리뷰 | 조율은 thread, 자동화는 exec |
| Subagent-in-Thread | host가 subagent를 제공하고 작업이 bounded일 때 | agent thread 내부에서 subagent 사용 |
| Scheduled Harness | 반복되는 unattended read-only 작업 | 외부 scheduler + codex exec + _workspace/ |
사용자가 multi-agent, multi-thread, orchestrator, team, fan-out/fan-in, harness를 명시하면 기본값은 Thread-Orchestrated Team입니다.
| 패턴 | 설명 | Thread-native 매핑 |
|---|---|---|
| Pipeline | 순차 의존 작업 | phase별 Thread/스킬을 순서대로 실행 |
| Fan-out/Fan-in | 병렬 독립 작업 | 여러 Agent Thread 병렬 실행, Orchestrator가 보고 병합 |
| Expert Pool | 맥락 의존 선택적 호출 | 필요할 때만 전문가 Thread 생성 |
| Producer-Reviewer | 생성 후 품질 리뷰 | 작성 Thread와 리뷰 Thread 분리 |
| Supervisor | 중앙 에이전트가 동적 배분 | Orchestrator가 탐색 중 새 brief를 동적 생성 |
| Hierarchical Delegation | 하향식 재귀 위임 | sub-orchestrator Thread가 하위 팀 관리 |
codex-harness가 생성하는 파일 (산출물 본문은 기본 한국어로 작성 — name frontmatter, 코드, 경로, 정착된 기술 용어는 그대로 유지):
your-project/
├── AGENTS.md # 라우팅 규칙, 스레드 오케스트레이션, 안전 정책, 변경 이력
├── .agents/
│ ├── agents/ # 재사용 가능한 전문 역할 정의
│ │ ├── analyst.md
│ │ ├── builder.md
│ │ └── reviewer.md
│ └── skills/ # 재사용 스킬 ("어떻게")
│ ├── <domain>-orchestrator/
│ │ └── SKILL.md # Orchestrator Thread 스킬: brief, gate, merge, evolve
│ └── <task>/
│ ├── SKILL.md
│ └── references/
└── _workspace/ # 파일 매개 핸드오프 상태
├── 00_requirements.md
├── 01_thread_board.md
├── 02_thread_briefs/
├── 03_thread_reports/
├── 04_merge_inputs/
└── 90_decisions.md
codex-harness 설치 후 Codex 세션에 아래 프롬프트를 복사해 넣어 보세요:
심층 리서치
심층 리서치용 하네스를 만들어줘. 웹 검색, 학술 자료, 커뮤니티 반응을 담당하는
Agent Thread로 fan-out하고, 리뷰 게이트로 교차 검증한 뒤 인용이 달린 보고서를
병합하는 Orchestrator Thread가 필요해.
웹사이트 개발
풀스택 웹사이트 개발 하네스를 만들어줘. 디자인, 프론트엔드(React/Next.js),
백엔드(API), QA를 스레드 파이프라인으로 조율하고, 와이어프레임부터 배포까지
_workspace/를 통해 핸드오프하게 해줘.
뉴스레터 / 콘텐츠 제작
주간 뉴스레터용 thread-native 하네스를 만들어줘: 리서치, 초안, 편집, 팩트체크
스레드가 _workspace/를 통해 핸드오프하고, Orchestrator Thread가 발행 전 각 phase를
게이트로 통과시키게 해줘.
코드 리뷰 & 리팩터링
종합 코드 리뷰 하네스를 만들어줘. 아키텍처, 보안, 성능, 스타일을 점검하는 병렬
Agent Thread와, 독립적인 read-only 감사를 위한 codex exec 작업을 두고 — 하나의
보고서로 병합해줘.
기술 문서화
이 코드베이스에서 API 문서를 생성하는 하네스를 만들어줘. 엔드포인트 분석, 설명
작성, 사용 예시 생성을 스레드로 나누고, 병합 전 완전성 리뷰 게이트를 거치게 해줘.
반복 운영 / 스케줄 하네스
이 반복 read-only 점검을 스케줄 하네스로 바꿔줘: 외부 scheduler가 codex exec
작업을 돌려 결과를 _workspace/에 쓰고, Orchestrator Thread가 필요할 때 board를
검토하게 해줘.
- Codex Thread가 실행 경계입니다. 각 thread는 독립 맥락, 역할 정체성, handoff report를 가진 durable한 전문 작업실이 될 수 있습니다.
- 오케스트레이터도 thread입니다. 작업 분해, 라우팅, phase gate, merge decision, partial rerun, evolution을 맡습니다.
- 파일 매개 상태가 thread를 durable하게 만듭니다.
_workspace/가 thread brief, report, merge input, decision을 세션 너머로 보존합니다. codex exec는 자동화 spine이지 전체 런타임이 아닙니다. 독립 리뷰, 구조화 추출, read-only audit, batch check에 사용합니다.- 안전은 설명이 아니라 정책으로 강제합니다. 자동화 단계의 위험을 sandbox/profile/hook 정책으로 제한합니다. 재사용 역할은
config.toml프로파일에 매핑하고, 외부 도구는 MCP 서버로 등록하며,AGENTS.md는 계층적으로 사용합니다.
| 저장소 | 위치 | codex-harness와의 관계 |
|---|---|---|
| revfactory/harness | Claude Code의 Team-Architecture Factory | 같은 서브 계층, 다른 런타임. codex-harness는 이 개념의 Codex Thread-native 에디션. Claude Code면 harness, Codex면 codex-harness. |
| coleam00/Archon | 결정론적 런타임 설정 팩토리 | 같은 L3, 이웃 서브 계층. 런타임 결정론은 Archon, 스레드 팀 아키텍처는 codex-harness, 또는 둘을 조합. |
Q1. 그냥 codex exec 스크립트를 짜는 것과 뭐가 다른가요?
A. codex exec 스크립트 더미에는 durable한 맥락도, 역할 정체성도, 핸드오프 규약도 없습니다. codex-harness는 각 Codex Thread를 독립 맥락과 표준 handoff report를 가진 전문 작업실로 취급하고, Orchestrator Thread가 _workspace/를 통해 조율합니다. codex exec는 여전히 — 독립 리뷰, 구조화 추출, read-only audit의 자동화 spine으로 — 쓰이지만, 스레드를 대체하지 않고 보조합니다.
Q2. revfactory/harness의 포크인가요?
A. 구현의 포크가 아니라 개념의 Codex 네이티브 포팅입니다. 6가지 팀 아키텍처 패턴, 스킬 생성 craft, 검증/진화 루프를 유지하되 Codex 표면(AGENTS.md, .agents/, Codex Threads, codex exec, 샌드박스/승인 정책, MCP, hooks)에만 생성하고, 위의 런타임 매핑을 추가합니다. .claude/, CLAUDE.md, Claude 전용 오케스트레이션 도구는 절대 만들지 않습니다.
Q3. 항상 멀티 스레드 팀이 나오나요?
A. 아닙니다. 하네스는 가장 작은 유용한 런타임을 선택합니다 — 작거나 순차적인 작업은 Single Thread로 처리합니다. 역할 분리, 병렬성, 독립 리뷰, 긴 맥락, 반복성이 실제로 있을 때만 Orchestrator + Agent Threads를 구성합니다. 실행 모드 표를 참고하세요.
MIT — LICENSE 참조. 개념은 revfactory/harness에서 차용했습니다.